diff --git a/Ix/Aiur/Compiler/Layout.lean b/Ix/Aiur/Compiler/Layout.lean index a43f1469b..59ba7789d 100644 --- a/Ix/Aiur/Compiler/Layout.lean +++ b/Ix/Aiur/Compiler/Layout.lean @@ -200,7 +200,7 @@ def opLayout : Bytecode.Op → LayoutM Unit | .u8Mul .. => do pushDegrees #[1, 1]; bumpAuxiliaries 2; bumpLookups | .u8XorSplit7 .. | .u8XorSplit4 .. => do pushDegrees #[1, 1]; bumpAuxiliaries 2; bumpLookups | .u8LessThan .. => do pushDegree 1; bumpAuxiliaries; bumpLookups - | .u32LessThan .. => do pushDegree 1; bumpAuxiliaries 12; bumpLookups 6 + | .u32LessThan .. => do pushDegree 1; bumpAuxiliaries 6; bumpLookups 6 | .unconstrainedU32Add a b => do let degrees ← (a ++ b).mapM getDegree pushDegrees $ .replicate 4 1 diff --git a/Ix/Aiur/Stages/Bytecode.lean b/Ix/Aiur/Stages/Bytecode.lean index 21c52fd66..8493cbad8 100644 --- a/Ix/Aiur/Stages/Bytecode.lean +++ b/Ix/Aiur/Stages/Bytecode.lean @@ -104,12 +104,14 @@ structure FunctionLayout where def FunctionLayout.width (l : FunctionLayout) : Nat := l.inputSize + l.selectors + l.auxiliaries +/-- Layout-only estimate of main and stage-2 width. This lacks the control +tree, compiled lookup degrees and PCS parameters; use the built system's +`circuitShapes` for actual widths after lookup tuning. -/ def FunctionLayout.totalWidth (l : FunctionLayout) : Nat := -- Stage 2 commits max(⌈L/k⌉, 1) chained partial accumulators (no message - -- inverses); see `multi_stark::lookup::stage2_width`. Mirrors the - -- synthesis grouping rule (`crates/aiur/src/synthesis.rs`): branchless - -- functions (one selector) have raw degree-1 lookup arguments, so their - -- lookups are grouped 2 per accumulator step. + -- inverses); see `multi_stark::lookup::stage2_width`. Retain the original + -- single-selector heuristic here; synthesis checks control flow and + -- retunes using compiled degrees and the FFT cost. let slots := if l.selectors == 1 && l.lookups >= 2 then (l.lookups + 1) / 2 else max l.lookups 1 diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean index 4847e37b4..c70ef281c 100644 --- a/Ix/Aiur/Stages/Codegen.lean +++ b/Ix/Aiur/Stages/Codegen.lean @@ -611,9 +611,8 @@ private def emitU8Sub (out : Nat) (i j : ValIdx) : Array RustStmt := declVal (out + 1) (.field (.var "__b2_sub") "1") ] -/-- `Op::U32LessThan`: mirror execute.rs lines 477-505. Pure - compare + 6-byte-pair range-check via - `bytes2_queries.bump_range_check` (constrained mode only). -/ +/-- `Op::U32LessThan`: mirror the checked comparison in `execute.rs`, + recording six scalar u16 range queries in constrained mode. -/ private def emitU32LessThan (out : Nat) (x y : ValIdx) : Array RustStmt := let blockExpr : String := s!"\{ let __a_val = __v_{x}.as_canonical_u64();" ++ @@ -622,17 +621,11 @@ private def emitU32LessThan (out : Nat) (x y : ValIdx) : Array RustStmt := s!" let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?;" ++ s!" let __result = G::from_bool(__a_u32 < __b_u32);" ++ s!" if !unconstrained \{" ++ - s!" let __x_bytes = __a_u32.to_le_bytes();" ++ - s!" let __z_bytes = __b_u32.to_le_bytes();" ++ - s!" let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1);" ++ - s!" let __y_bytes = __c_u32.to_le_bytes();" ++ - s!" record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]));" ++ - s!" record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]));" ++ - s!" record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]));" ++ - s!" record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]));" ++ - s!" record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]));" ++ - s!" record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]));" ++ - s!" } __result }" + s!" let __c_u32 = __a_u32.wrapping_sub(__b_u32);" ++ + s!" for __word in [__a_u32, __c_u32, __b_u32] \{" ++ + s!" record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16);" ++ + s!" record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16);" ++ + s!" } } __result }" #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)] private def u32PackExpr (xs : Array ValIdx) : String := diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean index 95eee1fef..9f5adb7f7 100644 --- a/Tests/Ix/IxVM.lean +++ b/Tests/Ix/IxVM.lean @@ -439,89 +439,89 @@ private def nameOfString (str : String) : Lean.Name := and an improvement has to be acknowledged by re-pinning. These pins include v3 contract decoding, canonicality checks, and scoped claim headers. -/ private def kernelCheckEntries : List (String × Nat) := [ - ("HEq", 129_580_132), - ("HEq.rec", 133_703_388), - ("Eq.rec", 133_072_615), - ("Nat", 129_633_587), - ("Nat.add", 170_479_894), - ("Nat.add_comm", 322_598_714), - ("Nat.decEq", 377_100_753), - ("Nat.decLe", 814_998_141), - ("Nat.sub_le_of_le_add", 1_957_472_572), - ("Nat.shiftRight_succ", 1_455_068_309), - ("Trans.mk", 137_107_353), - ("Array.append_assoc", 9_081_433_824), - ("Vector.append", 9_287_002_309), - ("IxVMPrim.nat_add_lit", 213_488_292), - ("IxVMPrim.nat_sub_lit", 228_506_721), - ("IxVMPrim.nat_mul_lit", 204_344_721), - ("IxVMPrim.nat_mul_big", 202_896_358), - ("IxVMPrim.nat_div_lit", 1_420_411_368), - ("IxVMPrim.nat_mod_lit", 1_447_938_067), - ("IxVMPrim.nat_succ_lit", 144_339_930), - ("IxVMPrim.nat_pred_lit", 166_168_846), - ("IxVMPrim.nat_gcd_lit", 2_232_501_380), - ("IxVMPrim.nat_land_lit", 3_652_583_530), - ("IxVMPrim.nat_lor_lit", 3_654_583_905), - ("IxVMPrim.nat_xor_lit", 3_674_202_062), - ("IxVMPrim.nat_shl_lit", 234_243_500), - ("IxVMPrim.nat_shr_lit", 1_435_151_445), - ("IxVMPrim.nat_pow_big", 395_904_832), - ("IxVMPrim.nat_beq_lit", 201_412_466), - ("IxVMPrim.nat_ble_lit", 196_817_405), - ("IxVMPrim.nat_cases_big", 166_401_353), - ("IxVMPrim.nat_dec_le", 833_212_679), - ("IxVMPrim.nat_dec_lt", 844_424_937), - ("IxVMPrim.nat_dec_eq", 416_937_906), - ("IxVMPrim.str_size_lit", 2_563_571_976), - ("IxVMPrim.bv_to_nat_lit", 2_135_250_014), - ("IxVMInd.Even", 206_886_515), - ("IxVMInd.Odd", 206_892_115), - ("IxVMInd.Even.rec", 226_129_215), - ("IxVMInd.Odd.rec", 226_131_072), - ("IxVMInd.IdxTeleN.rec", 161_370_130), - ("IxVMInd.IdxTeleB.rec", 161_368_435), - ("IxVMInd.SoloA.rec", 156_211_923), - ("IxVMInd.SoloB.rec", 156_211_088), - ("IxVMInd.UnsafeSquash", 131_473_733), - ("IxVMInd.Tree", 131_267_145), - ("IxVMInd.Tree.rec", 142_162_255), - ("IxVMInd.DedupM", 134_625_951), - ("IxVMInd.DedupM.rec", 149_282_091), - ("IxVMInd.DepthM", 133_016_231), - ("IxVMInd.DepthM.rec", 144_730_870), - ("String.Internal.append", 2_533_658_506), - ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 3_750_129_764), - ("Lean.Syntax.rec", 2_597_021_992), - ("IxVMInd.AuxTie", 326_741_066), - ("IxVMInd.AuxTie.rec", 373_345_395), - ("IxVMInd.HiddenIdx", 130_558_032), - ("IxVMInd.HiddenIdx.rec", 133_948_354), - ("IxVMInd.thmMajorUse", 517_920_579), - ("IxVMInd.partialKRec", 150_421_901), - ("IxVMInd.deepRebase", 221_891_341), - ("String.Slice.Pattern.Model.NoPrefixPatternModel.rec", 3_515_782_465), - ("Lean.Widget.TaggedText.rec", 2_566_008_609), - ("Lean.Doc.Part.rec", 2_611_709_383), - ("Lean.Doc.Block.rec", 2_847_867_384), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 132_585_241), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 136_255_212), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 135_184_337), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 135_184_337), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 135_184_337), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 132_875_994), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 145_089_906), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 145_088_324), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 135_184_337), - ("strOfListFoldSize", 2_848_829_120), - ("strOfListFoldSizeAscii", 2_849_606_441), - ("IxVMPrim.lazy_ble_offset", 234_904_821), - ("IxVMPrim.lazy_unit_cast", 558_233_712), - ("IxVMPrim.sizeof_unit", 161_110_680), - ("IxVMPerf.let_continuations", 165_727_825), - ("IxVMPerf.mul_row", 424_822_409), - ("IxVMPerf.context_tower", 518_991_146), - ("IxVMPerf.mul_wide", 268_439_307), + ("HEq", 108_495_574), + ("HEq.rec", 112_384_237), + ("Eq.rec", 111_757_088), + ("Nat", 108_546_656), + ("Nat.add", 146_389_791), + ("Nat.add_comm", 286_989_161), + ("Nat.decEq", 339_867_991), + ("Nat.decLe", 744_859_627), + ("Nat.sub_le_of_le_add", 1_808_798_827), + ("Nat.shiftRight_succ", 1_339_891_681), + ("Trans.mk", 115_473_215), + ("Array.append_assoc", 8_482_232_650), + ("Vector.append", 8_671_958_125), + ("IxVMPrim.nat_add_lit", 185_732_193), + ("IxVMPrim.nat_sub_lit", 199_325_550), + ("IxVMPrim.nat_mul_lit", 177_066_589), + ("IxVMPrim.nat_mul_big", 175_788_118), + ("IxVMPrim.nat_div_lit", 1_307_242_268), + ("IxVMPrim.nat_mod_lit", 1_332_536_900), + ("IxVMPrim.nat_succ_lit", 121_887_619), + ("IxVMPrim.nat_pred_lit", 141_744_465), + ("IxVMPrim.nat_gcd_lit", 2_061_457_700), + ("IxVMPrim.nat_land_lit", 3_376_640_812), + ("IxVMPrim.nat_lor_lit", 3_378_398_517), + ("IxVMPrim.nat_xor_lit", 3_395_994_274), + ("IxVMPrim.nat_shl_lit", 204_310_958), + ("IxVMPrim.nat_shr_lit", 1_320_506_095), + ("IxVMPrim.nat_pow_big", 361_514_602), + ("IxVMPrim.nat_beq_lit", 174_672_222), + ("IxVMPrim.nat_ble_lit", 170_365_817), + ("IxVMPrim.nat_cases_big", 142_102_154), + ("IxVMPrim.nat_dec_le", 761_507_789), + ("IxVMPrim.nat_dec_lt", 771_720_110), + ("IxVMPrim.nat_dec_eq", 376_436_724), + ("IxVMPrim.str_size_lit", 2_360_108_000), + ("IxVMPrim.bv_to_nat_lit", 1_969_340_217), + ("IxVMInd.Even", 179_459_070), + ("IxVMInd.Odd", 179_464_671), + ("IxVMInd.Even.rec", 197_286_374), + ("IxVMInd.Odd.rec", 197_288_230), + ("IxVMInd.IdxTeleN.rec", 137_630_968), + ("IxVMInd.IdxTeleB.rec", 137_629_273), + ("IxVMInd.SoloA.rec", 132_815_226), + ("IxVMInd.SoloB.rec", 132_814_391), + ("IxVMInd.UnsafeSquash", 110_174_981), + ("IxVMInd.Tree", 110_068_718), + ("IxVMInd.Tree.rec", 120_158_594), + ("IxVMInd.DedupM", 113_066_695), + ("IxVMInd.DedupM.rec", 126_681_373), + ("IxVMInd.DepthM", 111_645_324), + ("IxVMInd.DepthM.rec", 122_589_004), + ("String.Internal.append", 2_333_030_898), + ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 3_460_502_868), + ("Lean.Syntax.rec", 2_391_207_067), + ("IxVMInd.AuxTie", 287_499_396), + ("IxVMInd.AuxTie.rec", 330_644_761), + ("IxVMInd.HiddenIdx", 109_373_096), + ("IxVMInd.HiddenIdx.rec", 112_518_422), + ("IxVMInd.thmMajorUse", 469_426_294), + ("IxVMInd.partialKRec", 127_699_359), + ("IxVMInd.deepRebase", 193_715_227), + ("String.Slice.Pattern.Model.NoPrefixPatternModel.rec", 3_250_343_797), + ("Lean.Widget.TaggedText.rec", 2_363_428_548), + ("Lean.Doc.Part.rec", 2_405_755_939), + ("Lean.Doc.Block.rec", 2_628_895_151), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 111_219_505), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 114_568_146), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 113_736_777), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 113_736_777), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 113_736_777), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 111_504_500), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 122_803_609), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 122_802_027), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 113_736_777), + ("strOfListFoldSize", 2_621_459_865), + ("strOfListFoldSizeAscii", 2_622_117_638), + ("IxVMPrim.lazy_ble_offset", 205_262_728), + ("IxVMPrim.lazy_unit_cast", 506_194_228), + ("IxVMPrim.sizeof_unit", 137_095_643), + ("IxVMPerf.let_continuations", 143_072_956), + ("IxVMPerf.mul_row", 384_322_113), + ("IxVMPerf.context_tower", 467_936_574), + ("IxVMPerf.mul_wide", 236_260_962), ] /-- Variant of `kernelChecks`, pinned to the baseline diff --git a/Tests/Main.lean b/Tests/Main.lean index a33b64044..612432b18 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -281,8 +281,8 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [ let actual := (Aiur.computeStats vmEnv.compiled qc vmEnv.shapes).totalFftCost.round.toUInt64.toNat pure (LSpec.test - s!"Shard pipeline FFT matches: expected 7_072_190_269, got {actual}" - (actual = 7_072_190_269)) + s!"Shard pipeline FFT matches: expected 6_434_780_974, got {actual}" + (actual = 6_434_780_974)) LSpec.lspecIO (.ofList [("ixvm", [fullSeq, aiurSeq, arenaSeq, exploitSeq, paritySeq, shardSeq])]) []), diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean index d55f537a0..4ddb29de0 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -102,12 +102,10 @@ def selfTestSuite : IO UInt32 := do -- `recursive-verifier`: prove factorial(5)=120, verify it, reject tampering -- ════════════════════════════════════════════════════════════════════════════ -/-- A tiny Aiur program: a BRANCHLESS entrypoint (single selector, no match) -that routes its argument through store/load before calling `factorial`. Its -circuit has 4 lookups (return, store, load, call) with raw degree-1 -arguments, so synthesis groups them 2 per chained-accumulator step -(`lookup_group_size = 2`) — the recursive verifier's grouped logUp fold is -exercised end-to-end alongside the k = 1 branching/memory circuits. -/ +/-- A branching entrypoint with eighteen gated store/load/call/return lookups for +synthesis to choose two messages per accumulator at quotient degree four. +The smaller factorial and memory circuits retain quotient degree two, so +recursive verification exercises both degrees within the same proof. -/ def factorialProgram : Source.Toplevel := ⟦ pub fn factorial(n: G) -> G { match n { @@ -117,7 +115,26 @@ def factorialProgram : Source.Toplevel := ⟦ } pub fn fact_entry(n: G) -> G { - factorial(load(store(n))) + match n { + 0 => 1, + _ => + let a = load(store(n)); + let b = load(store(n + 1)); + let c = load(store(n + 2)); + let d = load(store(n + 3)); + let e = load(store(n + 4)); + let f = load(store(n + 5)); + let g = load(store(n + 6)); + let h = load(store(n + 7)); + assert_eq!(b, a + 1); + assert_eq!(c, a + 2); + assert_eq!(d, a + 3); + assert_eq!(e, a + 4); + assert_eq!(f, a + 5); + assert_eq!(g, a + 6); + assert_eq!(h, a + 7); + factorial(a), + } } ⟧ @@ -163,6 +180,8 @@ def endToEndSuite : IO UInt32 := do | .ok result => pure result | .error e => IO.eprintln s!"factorial prove failed: {e}"; return 1 let expectedClaim := buildClaim facIdx input #[Aiur.G.ofNat 120] + let mixedQuotients := facSystem.circuitShapes.any (·.quotientDegree == 4) && + facSystem.circuitShapes.any (·.quotientDegree == 2) -- Verify and serialize the proof transport consumed in-circuit. let proofBytes ← match facSystem.proofToAdviceBytes claim proof with | .ok bytes => pure bytes @@ -237,6 +256,7 @@ def endToEndSuite : IO UInt32 := do vCompiled.bytecode.executeMultiStark vIdx badClaimInput proofBytes vkBytes badClaimBytes lspecIO (.ofList [("recursive-verifier", [ test "factorial(5) claim = #[functionChannel, facIdx, 5, 120]" (claim == expectedClaim), + test s!"inner proof exercises quotient degrees two and four (main/stage2/quotient: {facSystem.circuitShapes.map fun s => (s.mainWidth, s.stage2Width, s.quotientDegree)})" mixedQuotients, expectOk "inner factorial proof verifies" innerVerify, expectOk "verifier accepts honest proof (vk digest bound + OOD + FRI)" honest, test "codegen'd verifier matches interpreter (output + query counts)" parity, diff --git a/crates/aiur/src/constraints.rs b/crates/aiur/src/constraints.rs index b97a91a82..83ecd7c31 100644 --- a/crates/aiur/src/constraints.rs +++ b/crates/aiur/src/constraints.rs @@ -13,10 +13,10 @@ use crate::{ bytes1::{Bytes1, Bytes1Op}, bytes2::{Bytes2, Bytes2Op}, }, - memory_channel, u8_add_channel, u8_and_channel, u8_bit_decomposition_channel, - u8_less_than_channel, u8_mul_channel, u8_or_channel, u8_range_check_channel, - u8_shift_left_channel, u8_shift_right_channel, u8_sub_channel, - u8_xor_channel, u8_xor_split4_channel, u8_xor_split7_channel, + memory_channel, u8_add_channel, u8_bit_decomposition_channel, u8_mul_channel, + u8_range_check_channel, u8_shift_left_channel, u8_shift_right_channel, + u8_sub_channel, u8_xor_channel, u8_xor_split4_channel, u8_xor_split7_channel, + u16_range_check_channel, }; type Expr = multi_stark::expr::Expr; @@ -121,6 +121,16 @@ impl ConstraintState { var(self.column - 1) } + fn range_u16(&mut self, sel: &Expr, limb: Expr) { + let args = vec![ + self.gate(sel, konst(u16_range_check_channel())), + self.gate(sel, limb), + ]; + let lookup = self.next_lookup(); + combine_lookup_args(lookup, args); + lookup.multiplicity = lookup.multiplicity.clone() + sel.clone(); + } + fn save(&mut self) -> SharedState { SharedState { column: self.column, @@ -661,30 +671,39 @@ impl Op { state.map.push((z, 1)); state.map.push((borrow, x_deg.max(y_deg).max(1))); }, - Op::U8And(i, j) => bytes2_constraints( - *i, - *j, - &Bytes2Op::And, - u8_and_channel(), - sel.clone(), - state, - ), - Op::U8Or(i, j) => bytes2_constraints( - *i, - *j, - &Bytes2Op::Or, - u8_or_channel(), - sel.clone(), - state, - ), - Op::U8LessThan(i, j) => bytes2_constraints( - *i, - *j, - &Bytes2Op::LessThan, - u8_less_than_channel(), - sel.clone(), - state, - ), + Op::U8And(i, j) | Op::U8Or(i, j) | Op::U8LessThan(i, j) => { + let x = state.map[*i].0.clone(); + let y = state.map[*j].0.clone(); + let output = state.next_auxiliary(); + // The table binds x and y to bytes. Each affine result uniquely + // determines the original output over Goldilocks (2 and 256 are + // nonzero), without a new column or polynomial constraint. + let (channel, result) = match self { + Op::U8And(..) => ( + u8_xor_channel(), + x.clone() + y.clone() - konst(G::TWO) * output.clone(), + ), + Op::U8Or(..) => ( + u8_xor_channel(), + konst(G::TWO) * output.clone() - x.clone() - y.clone(), + ), + Op::U8LessThan(..) => ( + u8_sub_channel(), + x.clone() - y.clone() + konst(G::from_u16(256)) * output.clone(), + ), + _ => unreachable!(), + }; + let args = vec![ + state.gate(sel, konst(channel)), + state.gate(sel, x), + state.gate(sel, y), + state.gate(sel, result), + ]; + let lookup = state.next_lookup(); + combine_lookup_args(lookup, args); + lookup.multiplicity = lookup.multiplicity.clone() + sel.clone(); + state.map.push((output, 1)); + }, Op::U8XorSplit7(i, j) => bytes2_constraints( *i, *j, @@ -716,78 +735,40 @@ impl Op { lookup.multiplicity = lookup.multiplicity.clone() + sel.clone(); }, Op::U32LessThan(x_idx, y_idx) => { - // u32 less-than via addition carry chain. - // - // Goal: constrain output = 1 if a < b, 0 otherwise, where a and b are - // u32 values (< 2^32) represented as Goldilocks field elements. - // - // Approach: find witness c (non-deterministic) such that - // a + c + 1 = b + carry · 2^32 - // The +1 ensures strict less-than (not ≤). Then a < b ⟺ carry = 0. - // - // Decompose a, c, b into 4 little-endian bytes each (x_k, y_k, z_k). - // The carry chain is computed as polynomial expressions: - // c_k = (x_k + y_k + prev - z_k) / 256 - // where prev = 1 for k=0, prev = c_{k-1} for k>0. - // Each c_k is constrained to be boolean (assert_bool). - // - // All 12 bytes are range-checked via 6 Bytes2 range-check lookups - // (2 bytes per lookup). - // - // Resources: 12 auxiliaries, 6 lookups, 6 polynomial constraints - // (2 decomposition + 4 assert_bool). + // Bound a, b and the witness c to u32 values with two u16 limbs each. + // The whole-word carry establishes the integer relation + // b + c = a + carry * 2^32. + // With c = (a - b) mod 2^32, a < b iff the carry is one; equality + // gives c = carry = 0. The bounded integer relation cannot wrap p. + // Six scalar range lookups use the shared table's u16 channel. let a = state.map[*x_idx].0.clone(); let b = state.map[*y_idx].0.clone(); - - // Byte decomposition auxiliaries - let x_bytes: [Expr; 4] = array::from_fn(|_| state.next_auxiliary()); - let y_bytes: [Expr; 4] = array::from_fn(|_| state.next_auxiliary()); - let z_bytes: [Expr; 4] = array::from_fn(|_| state.next_auxiliary()); - - // Decomposition constraints: a = Σ x_k * 256^k, b = Σ z_k * 256^k - let base = - |k: usize| G::from_u64(256u64.pow(u32::try_from(k).unwrap())); - let recompose = |bytes: &[Expr; 4]| { - bytes.iter().enumerate().fold(konst(G::ZERO), |acc, (k, b)| { - acc + b.clone() * konst(base(k)) - }) + let a_limbs: [Expr; 2] = array::from_fn(|_| state.next_auxiliary()); + let c_limbs: [Expr; 2] = array::from_fn(|_| state.next_auxiliary()); + let b_limbs: [Expr; 2] = array::from_fn(|_| state.next_auxiliary()); + let recompose = |limbs: &[Expr; 2]| { + limbs[0].clone() + limbs[1].clone() * konst(G::from_u32(65536)) }; - state.constraints.zeros.push(sel.clone() * (a - recompose(&x_bytes))); - state.constraints.zeros.push(sel.clone() * (b - recompose(&z_bytes))); - - // Carry chain: a + c + 1 = b + carry * 2^32 - let mut carry = konst(G::ONE); // initial carry = 1 for strict less-than - for k in 0..4 { - let sum = x_bytes[k].clone() + y_bytes[k].clone() + carry; - carry = (sum - z_bytes[k].clone()) * konst(*INV_256); - state.constraints.zeros.push( - sel.clone() * (carry.clone() * (carry.clone() - konst(G::ONE))), - ); - } + state + .constraints + .zeros + .push(sel.clone() * (a.clone() - recompose(&a_limbs))); + state + .constraints + .zeros + .push(sel.clone() * (b.clone() - recompose(&b_limbs))); - // Range-check byte pairs via Bytes2 lookups - let rc_channel = u8_range_check_channel(); - for pair in [ - (&x_bytes[0], &x_bytes[1]), - (&x_bytes[2], &x_bytes[3]), - (&y_bytes[0], &y_bytes[1]), - (&y_bytes[2], &y_bytes[3]), - (&z_bytes[0], &z_bytes[1]), - (&z_bytes[2], &z_bytes[3]), - ] { - let lookup_args = vec![ - state.gate(sel, konst(rc_channel)), - state.gate(sel, pair.0.clone()), - state.gate(sel, pair.1.clone()), - ]; - let lookup = state.next_lookup(); - combine_lookup_args(lookup, lookup_args); - lookup.multiplicity = lookup.multiplicity.clone() + sel.clone(); + // Inputs are affine after multiplication materialization. Use the + // whole words directly: this carry is an expression, not a column. + let carry = (b + recompose(&c_limbs) - a) * INV_2_POW_32_EXPR.clone(); + state + .constraints + .zeros + .push(sel.clone() * carry.clone() * (carry.clone() - konst(G::ONE))); + for limb in a_limbs.into_iter().chain(c_limbs).chain(b_limbs) { + state.range_u16(sel, limb); } - - // Output: 1 - carry - let output = konst(G::ONE) - carry; - state.map.push((output, 1)); + state.map.push((carry, 1)); }, Op::IOSetInfo(..) | Op::IOWrite(..) | Op::Debug(..) => (), Op::UnconstrainedBigUintDivMod(_, _) => { diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs index cfa91823c..9a6ae7a4a 100644 --- a/crates/aiur/src/execute.rs +++ b/crates/aiur/src/execute.rs @@ -567,22 +567,12 @@ impl Function { let result = G::from_bool(a_u32 < b_u32); map.push(result); if !unconstrained { - let x_bytes = a_u32.to_le_bytes(); - let z_bytes = b_u32.to_le_bytes(); - let c_u32 = b_u32.wrapping_sub(a_u32).wrapping_sub(1); - let y_bytes = c_u32.to_le_bytes(); - // Bump range-check queries for byte pairs - for (i, j) in [ - (x_bytes[0], x_bytes[1]), - (x_bytes[2], x_bytes[3]), - (y_bytes[0], y_bytes[1]), - (y_bytes[2], y_bytes[3]), - (z_bytes[0], z_bytes[1]), - (z_bytes[2], z_bytes[3]), - ] { + let c_u32 = a_u32.wrapping_sub(b_u32); + for word in [a_u32, c_u32, b_u32] { record .bytes2_queries - .bump_range_check(&G::from_u8(i), &G::from_u8(j)); + .bump_u16_range_check((word & 0xffff) as u16); + record.bytes2_queries.bump_u16_range_check((word >> 16) as u16); } } }, diff --git a/crates/aiur/src/gadgets/bytes2.rs b/crates/aiur/src/gadgets/bytes2.rs index e013a6a34..2d7c0fc54 100644 --- a/crates/aiur/src/gadgets/bytes2.rs +++ b/crates/aiur/src/gadgets/bytes2.rs @@ -6,23 +6,21 @@ use multi_stark::{ }; use crate::{ - G, execute::QueryRecord, gadgets::AiurGadget, u8_add_channel, u8_and_channel, - u8_less_than_channel, u8_mul_channel, u8_or_channel, u8_range_check_channel, - u8_sub_channel, u8_xor_channel, u8_xor_split4_channel, u8_xor_split7_channel, + G, execute::QueryRecord, gadgets::AiurGadget, u8_add_channel, u8_mul_channel, + u8_range_check_channel, u8_sub_channel, u8_xor_channel, + u8_xor_split4_channel, u8_xor_split7_channel, u16_range_check_channel, }; /// Number of columns in the trace with multiplicities for /// - xor /// - overflowing add /// - overflowing sub -/// - and -/// - or -/// - less_than /// - range_check /// - mul /// - xor_split7 /// - xor_split4 -const TRACE_WIDTH: usize = 10; +/// - scalar u16 range_check +const TRACE_WIDTH: usize = 8; /// Number of columns in the preprocessed trace: /// - first raw byte value @@ -32,16 +30,18 @@ const TRACE_WIDTH: usize = 10; /// `(x + y - z) / 256`, so it needs no column or lookup) /// - sub result (low byte only; the borrow is derived in-circuit as /// `(z + y - x) / 256`, so it needs no column or lookup) -/// - and result -/// - or result -/// - less_than result /// - mul low byte /// - mul high byte /// - xor_split7 high and shifted-low outputs /// - xor_split4 high and shifted-low outputs -const PREPROCESSED_TRACE_WIDTH: usize = 14; +const PREPROCESSED_TRACE_WIDTH: usize = 11; /// AIR implementer for arity 2 byte-related lookups. +/// +/// AND and OR reuse XOR through `a + b - 2*and` and `2*or - a - b`. +/// Comparison reuses subtraction through `a - b + 256*less_than`. +/// The caller keeps its original output column; these derived arguments +/// need neither additional witnesses nor separate table multiplicities. pub struct Bytes2; pub enum Bytes2Op { @@ -94,15 +94,6 @@ impl AiurGadget for Bytes2 { // Sub low byte (borrow derived in-circuit, no column) trace_values.push(G::from_u8(i.wrapping_sub(j))); - // And - trace_values.push(G::from_u8(i & j)); - - // Or - trace_values.push(G::from_u8(i | j)); - - // Less than - trace_values.push(G::from_bool(i < j)); - // Mul (low byte, high byte) let p = u16::from(i) * u16::from(j); trace_values.push(G::from_u8((p & 0xff) as u8)); @@ -175,25 +166,21 @@ impl AiurGadget for Bytes2 { let xor_channel = Expr::constant(u8_xor_channel()); let add_channel = Expr::constant(u8_add_channel()); let sub_channel = Expr::constant(u8_sub_channel()); - let and_channel = Expr::constant(u8_and_channel()); - let or_channel = Expr::constant(u8_or_channel()); - let less_than_channel = Expr::constant(u8_less_than_channel()); let range_check_channel = Expr::constant(u8_range_check_channel()); let mul_channel = Expr::constant(u8_mul_channel()); let xor_split7_channel = Expr::constant(u8_xor_split7_channel()); let xor_split4_channel = Expr::constant(u8_xor_split4_channel()); + let u16_range_channel = Expr::constant(u16_range_check_channel()); // Multiplicity columns let xor_multiplicity = Expr::main(0); let add_multiplicity = Expr::main(1); let sub_multiplicity = Expr::main(2); - let and_multiplicity = Expr::main(3); - let or_multiplicity = Expr::main(4); - let less_than_multiplicity = Expr::main(5); - let range_check_multiplicity = Expr::main(6); - let mul_multiplicity = Expr::main(7); - let xor_split7_multiplicity = Expr::main(8); - let xor_split4_multiplicity = Expr::main(9); + let range_check_multiplicity = Expr::main(3); + let mul_multiplicity = Expr::main(4); + let xor_split7_multiplicity = Expr::main(5); + let xor_split4_multiplicity = Expr::main(6); + let u16_range_multiplicity = Expr::main(7); // Preprocessed columns let i = Expr::preprocessed(0); @@ -201,15 +188,12 @@ impl AiurGadget for Bytes2 { let xor = Expr::preprocessed(2); let add_r = Expr::preprocessed(3); let sub_r = Expr::preprocessed(4); - let and = Expr::preprocessed(5); - let or = Expr::preprocessed(6); - let less_than = Expr::preprocessed(7); - let mul_lo = Expr::preprocessed(8); - let mul_hi = Expr::preprocessed(9); - let xor_split7_hi = Expr::preprocessed(10); - let xor_split7_lo = Expr::preprocessed(11); - let xor_split4_hi = Expr::preprocessed(12); - let xor_split4_lo = Expr::preprocessed(13); + let mul_lo = Expr::preprocessed(5); + let mul_hi = Expr::preprocessed(6); + let xor_split7_hi = Expr::preprocessed(7); + let xor_split7_lo = Expr::preprocessed(8); + let xor_split4_hi = Expr::preprocessed(9); + let xor_split4_lo = Expr::preprocessed(10); // pull = negated multiplicity. let pull_xor = Lookup { @@ -227,21 +211,6 @@ impl AiurGadget for Bytes2 { args: vec![sub_channel, i.clone(), j.clone(), sub_r], }; - let pull_and = Lookup { - multiplicity: -and_multiplicity, - args: vec![and_channel, i.clone(), j.clone(), and], - }; - - let pull_or = Lookup { - multiplicity: -or_multiplicity, - args: vec![or_channel, i.clone(), j.clone(), or], - }; - - let pull_less_than = Lookup { - multiplicity: -less_than_multiplicity, - args: vec![less_than_channel, i.clone(), j.clone(), less_than], - }; - let pull_mul = Lookup { multiplicity: -mul_multiplicity, args: vec![mul_channel, i.clone(), j.clone(), mul_lo, mul_hi], @@ -264,20 +233,31 @@ impl AiurGadget for Bytes2 { }; let pull_xor_split4 = Lookup { multiplicity: -xor_split4_multiplicity, - args: vec![xor_split4_channel, i, j, xor_split4_hi, xor_split4_lo], + args: vec![ + xor_split4_channel, + i.clone(), + j.clone(), + xor_split4_hi, + xor_split4_lo, + ], + }; + + // The preprocessed row enumerates exactly one integer in 0..2^16. + // Keep this separate from the two independent byte-range arguments. + let pull_u16_range = Lookup { + multiplicity: -u16_range_multiplicity, + args: vec![u16_range_channel, i * Expr::constant(G::from_u16(256)) + j], }; vec![ pull_xor, pull_add, pull_sub, - pull_and, - pull_or, - pull_less_than, pull_range_check, pull_mul, pull_xor_split7, pull_xor_split4, + pull_u16_range, ] } @@ -287,101 +267,45 @@ impl AiurGadget for Bytes2 { slot_arg_widths: &[usize], ) -> (RowMajorMatrix, LookupValues) { let mut rows = vec![G::ZERO; 256 * 256 * TRACE_WIDTH]; - - // There are `TRACE_WIDTH` lookups per row, one for each multiplicity. let mut builder = LookupValues::builder(256 * 256, slot_arg_widths); let mut row_writers = builder.rows_mut(); - - let xor_channel = u8_xor_channel(); - let add_channel = u8_add_channel(); - let sub_channel = u8_sub_channel(); - let and_channel = u8_and_channel(); - let or_channel = u8_or_channel(); - let less_than_channel = u8_less_than_channel(); - let range_check_channel = u8_range_check_channel(); - let mul_channel = u8_mul_channel(); - let xor_split7_channel = u8_xor_split7_channel(); - let xor_split4_channel = u8_xor_split4_channel(); - - rows + for (((row_idx, row), counts), row_lookups) in rows .as_chunks_mut::() .0 .iter_mut() .enumerate() .zip(&record.bytes2_queries.0) .zip(row_writers.iter_mut()) - .for_each( - |( - ( - (row_idx, row), - &[ - xor, - add, - sub, - and, - or, - less_than, - range_check, - mul, - xor_split7, - xor_split4, - ], - ), - row_lookups, - )| { - let i = G::from_usize(row_idx / 256); - let j = G::from_usize(row_idx % 256); - - row[0] = xor; - row[1] = add; - row[2] = sub; - row[3] = and; - row[4] = or; - row[5] = less_than; - row[6] = range_check; - row[7] = mul; - row[8] = xor_split7; - row[9] = xor_split4; - - // Pull xor. - row_lookups.pull(0, xor, &[xor_channel, i, j, Self::xor(&i, &j)]); - - // Pull add (low byte only; carry derived in-circuit). - let (r, _o) = Self::add(&i, &j); - row_lookups.pull(1, add, &[add_channel, i, j, r]); - - // Pull sub (low byte only; borrow derived in-circuit). - let (r, _u) = Self::sub(&i, &j); - row_lookups.pull(2, sub, &[sub_channel, i, j, r]); - - // Pull and. - row_lookups.pull(3, and, &[and_channel, i, j, Self::and(&i, &j)]); - - // Pull or. - row_lookups.pull(4, or, &[or_channel, i, j, Self::or(&i, &j)]); - - // Pull less_than. - row_lookups.pull( - 5, - less_than, - &[less_than_channel, i, j, Self::less_than(&i, &j)], - ); - // Pull range_check. - row_lookups.pull(6, range_check, &[range_check_channel, i, j]); - - // Pull mul. - let (lo, hi) = Self::mul(&i, &j); - row_lookups.pull(7, mul, &[mul_channel, i, j, lo, hi]); - - // Pull xor_split7. - let (hi, lo) = Self::xor_split7(&i, &j); - row_lookups.pull(8, xor_split7, &[xor_split7_channel, i, j, hi, lo]); - - // Pull xor_split4. - let (hi, lo) = Self::xor_split4(&i, &j); - row_lookups.pull(9, xor_split4, &[xor_split4_channel, i, j, hi, lo]); - }, + { + let [xor, add, sub, range_check, mul, xor_split7, xor_split4, u16_range] = + *counts; + let i = G::from_usize(row_idx / 256); + let j = G::from_usize(row_idx % 256); + row.copy_from_slice(counts); + + // AND and OR queries also pull XOR; comparisons also pull subtraction. + row_lookups.pull(0, xor, &[u8_xor_channel(), i, j, Self::xor(&i, &j)]); + let (r, _) = Self::add(&i, &j); + row_lookups.pull(1, add, &[u8_add_channel(), i, j, r]); + let (r, _) = Self::sub(&i, &j); + row_lookups.pull(2, sub, &[u8_sub_channel(), i, j, r]); + row_lookups.pull( + Self::RANGE_CHECK_COLUMN, + range_check, + &[u8_range_check_channel(), i, j], + ); + let (lo, hi) = Self::mul(&i, &j); + row_lookups.pull(4, mul, &[u8_mul_channel(), i, j, lo, hi]); + let (hi, lo) = Self::xor_split7(&i, &j); + row_lookups.pull(5, xor_split7, &[u8_xor_split7_channel(), i, j, hi, lo]); + let (hi, lo) = Self::xor_split4(&i, &j); + row_lookups.pull(6, xor_split4, &[u8_xor_split4_channel(), i, j, hi, lo]); + row_lookups.pull( + Self::U16_RANGE_CHECK_COLUMN, + u16_range, + &[u16_range_check_channel(), G::from_usize(row_idx)], ); + } drop(row_writers); (RowMajorMatrix::new(rows, TRACE_WIDTH), builder.finish()) } @@ -409,31 +333,36 @@ impl Bytes2Queries { } pub(crate) fn bump_and(&mut self, i: &G, j: &G) { - self.bump_multiplicity_for(i, j, 3) + self.bump_xor(i, j) } pub(crate) fn bump_or(&mut self, i: &G, j: &G) { - self.bump_multiplicity_for(i, j, 4) + self.bump_xor(i, j) } pub(crate) fn bump_less_than(&mut self, i: &G, j: &G) { - self.bump_multiplicity_for(i, j, 5) + self.bump_sub(i, j) } pub fn bump_range_check(&mut self, i: &G, j: &G) { - self.bump_multiplicity_for(i, j, 6) + self.bump_multiplicity_for(i, j, Bytes2::RANGE_CHECK_COLUMN) + } + + /// Record a scalar u16 query on its distinct range channel. + pub fn bump_u16_range_check(&mut self, limb: u16) { + self.0[usize::from(limb)][Bytes2::U16_RANGE_CHECK_COLUMN] += G::ONE; } pub(crate) fn bump_mul(&mut self, i: &G, j: &G) { - self.bump_multiplicity_for(i, j, 7) + self.bump_multiplicity_for(i, j, 4) } pub(crate) fn bump_xor_split7(&mut self, i: &G, j: &G) { - self.bump_multiplicity_for(i, j, 8) + self.bump_multiplicity_for(i, j, 5) } pub(crate) fn bump_xor_split4(&mut self, i: &G, j: &G) { - self.bump_multiplicity_for(i, j, 9) + self.bump_multiplicity_for(i, j, 6) } pub(crate) fn bump_multiplicity_for(&mut self, i: &G, j: &G, col: usize) { @@ -445,6 +374,11 @@ impl Bytes2Queries { } impl Bytes2 { + /// Shared row and lookup-slot index of the byte-pair range channel. + pub(crate) const RANGE_CHECK_COLUMN: usize = 3; + /// Shared row and lookup-slot index of the scalar u16 range channel. + pub(crate) const U16_RANGE_CHECK_COLUMN: usize = 7; + #[inline] pub fn xor(i: &G, j: &G) -> G { let i: u8 = i.as_canonical_u64().try_into().unwrap(); diff --git a/crates/aiur/src/lib.rs b/crates/aiur/src/lib.rs index 470d08b18..16014f4a2 100644 --- a/crates/aiur/src/lib.rs +++ b/crates/aiur/src/lib.rs @@ -3,6 +3,7 @@ pub mod constraints; pub mod execute; pub mod gadgets; mod lookup_budget; +mod lookup_groups; mod lookup_shapes; pub mod memory; pub mod querymap; @@ -59,6 +60,9 @@ pub fn u8_sub_channel() -> G { G::from_u8(7) } +// Legacy AND/OR/comparison channel IDs remain reserved. Their operations +// now use affine arguments on the XOR/subtraction channels; Bytes2 does not +// provide these three channels. Keep later channel IDs unchanged. #[inline] pub fn u8_and_channel() -> G { G::from_u8(8) @@ -93,3 +97,9 @@ pub fn u8_xor_split7_channel() -> G { pub fn u8_xor_split4_channel() -> G { G::from_u8(14) } + +/// Scalar u16 range checks have a distinct channel from byte pairs. +#[inline] +pub fn u16_range_check_channel() -> G { + G::from_u8(15) +} diff --git a/crates/aiur/src/lookup_groups.rs b/crates/aiur/src/lookup_groups.rs new file mode 100644 index 000000000..a26d29328 --- /dev/null +++ b/crates/aiur/src/lookup_groups.rs @@ -0,0 +1,184 @@ +// Copyright (c) 2026 Argument Computer Corporation. +// SPDX-License-Identifier: MIT OR Apache-2.0 + +//! Choose lookup groups from the compiled degrees and the FFT tradeoff. +//! This runs before exposing the system or constructing its transcript. + +use multi_stark::{ + expr::Source, + graph::Node, + lookup::{ + MAX_LOOKUP_GROUP, logup_constraint_count, logup_max_degree, stage2_width, + }, + system::Circuit, +}; + +use crate::G; + +/// The group-dependent part of `Aiur.fftCost`, divided by row height. +/// For h >= 2 it is `slope * log2(h) + intercept`; h = 1 uses the +/// repository model's clamped transform cost. Main-trace work cancels. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +struct FftCost { + one: u128, + two: u128, + slope: u128, + intercept: u128, +} + +impl FftCost { + fn new( + stage2: usize, + quotient: usize, + blowup: usize, + degree: usize, + ) -> Option { + if !quotient.is_power_of_two() || !blowup.is_power_of_two() { + return None; + } + let log_q = u128::from(quotient.ilog2()); + let log_b = u128::from(blowup.ilog2()); + let qd = (quotient as u128).checked_mul(degree as u128)?; + let b = blowup as u128; + let trace = (b + 1).checked_mul(stage2 as u128)?; + let slope = (b + 1).checked_mul((stage2 as u128).checked_add(qd)?)?; + let intercept = + qd.checked_mul(log_q.checked_add(b.checked_mul(log_b)?)?)?; + let one = trace.checked_add(qd.checked_mul( + log_q.max(1).checked_add(b.checked_mul(log_b.max(1))?)?, + )?)?; + let two = slope.checked_add(intercept)?; + Some(Self { one, two, slope, intercept }) + } + + /// These three comparisons imply no larger FFT cost for every integer + /// height h >= 1, including both padded and raw-height statistics. + fn no_worse_than(self, other: Self) -> bool { + self.one <= other.one && self.two <= other.two && self.slope <= other.slope + } + + fn score(self) -> (u128, u128, u128) { + (self.slope, self.intercept, self.one) + } +} + +fn max_degree(circuit: &Circuit, group: usize) -> usize { + circuit + .graph + .max_constraint_degree + .max(logup_max_degree(&circuit.graph, group)) as usize +} + +fn quotient_degree(circuit: &Circuit, group: usize) -> Option { + (max_degree(circuit, group).max(2) - 1).checked_next_power_of_two() +} + +/// The pinned backend compiles user constraints and lookup expressions only; +/// its logUp constraints are evaluated directly from this circuit metadata. +/// Its prover key contains only preprocessed PCS data, which grouping does +/// not change. Keep all derived metadata synchronized before either is used. +pub(crate) fn set_group(circuit: &mut Circuit, group: usize, degree: usize) { + circuit.lookup_group_size = group; + circuit.stage_2_width = stage2_width(circuit.num_lookups, group, degree); + circuit.constraint_count = circuit.graph.zeros.len() + + logup_constraint_count(circuit.num_lookups, group, degree); + circuit.max_constraint_degree = max_degree(circuit, group); +} + +pub(crate) fn retune(circuit: &mut Circuit, blowup: usize, degree: usize) { + // Aiur's authored constraints never refer to stage 2. Retain the layout + // if a future circuit does: changing its column count would need a + // separate proof that those references still have the intended meaning. + if circuit + .graph + .nodes + .iter() + .any(|node| matches!(node, Node::Var(col) if col.source == Source::Stage2)) + { + return; + } + let Some(baseline) = FftCost::new( + circuit.stage_2_width, + circuit.quotient_degree(), + blowup, + degree, + ) else { + return; + }; + let mut best_group = circuit.lookup_group_size; + let mut best_cost = baseline; + for group in 1..=circuit.num_lookups.clamp(1, MAX_LOOKUP_GROUP) { + let Some(quotient) = quotient_degree(circuit, group) else { continue }; + if quotient > blowup { + continue; + } + let Some(cost) = FftCost::new( + stage2_width(circuit.num_lookups, group, degree), + quotient, + blowup, + degree, + ) else { + continue; + }; + if cost.no_worse_than(baseline) && cost.score() < best_cost.score() { + best_group = group; + best_cost = cost; + } + } + set_group(circuit, best_group, degree); +} + +#[cfg(test)] +mod tests { + use super::*; + + fn cost_at(stage2: usize, quotient: usize, blowup: usize, h: usize) -> f64 { + let [stage2, quotient, blowup, h] = [stage2, quotient, blowup, h] + .map(|n| f64::from(u32::try_from(n).unwrap())); + let transform = |n: f64| n * n.max(2.0).log2(); + (blowup + 1.0) * stage2 * transform(h) + + 2.0 * transform(quotient * h) + + 2.0 * quotient * transform(blowup * h) + } + + #[test] + fn fft_dominance_preserves_cost_at_small_and_large_heights() { + for blowup in [1, 2, 4, 8] { + for before_q in [1, 2, 4, 8] { + for after_q in [1, 2, 4, 8] { + for before_s2 in [2, 4, 8, 16, 32, 128] { + for after_s2 in [2, 4, 8, 16, 32, 128] { + let before = + FftCost::new(before_s2, before_q, blowup, 2).unwrap(); + let after = FftCost::new(after_s2, after_q, blowup, 2).unwrap(); + if after.no_worse_than(before) { + for h in [1, 2, 3, 7, 16, 255, 1_024, 65_536, 1 << 30] { + assert!( + cost_at(after_s2, after_q, blowup, h) + <= cost_at(before_s2, before_q, blowup, h) + ); + } + } + } + } + } + } + } + } + + #[test] + fn fft_cost_rejects_invalid_dimensions_and_overflow() { + assert!(FftCost::new(1, 0, 4, 2).is_none()); + assert!(FftCost::new(1, 3, 4, 2).is_none()); + assert!(FftCost::new(1, 2, 3, 2).is_none()); + assert!( + FftCost::new( + usize::MAX, + 1 << (usize::BITS - 1), + 1 << (usize::BITS - 1), + usize::MAX + ) + .is_none() + ); + } +} diff --git a/crates/aiur/src/lookup_shapes.rs b/crates/aiur/src/lookup_shapes.rs index 37a6b1bde..170ed5bcc 100644 --- a/crates/aiur/src/lookup_shapes.rs +++ b/crates/aiur/src/lookup_shapes.rs @@ -17,9 +17,63 @@ fn canonical_size(size: usize) -> bool { u64::try_from(size).is_ok_and(|size| size < G::ORDER_U64) } +#[derive(Clone, Copy)] +enum ReturnArity { + NoReturns, + Exact(usize), + Inconsistent, +} + +impl ReturnArity { + fn merge(self, other: Self) -> Self { + match (self, other) { + (Self::NoReturns, arity) | (arity, Self::NoReturns) => arity, + (Self::Exact(a), Self::Exact(b)) if a == b => Self::Exact(a), + _ => Self::Inconsistent, + } + } + + fn accepts(self, size: usize) -> bool { + match self { + Self::NoReturns => true, + Self::Exact(arity) => arity == size, + Self::Inconsistent => false, + } + } +} + +/// Cached for public constrained entries in the system's immutable program. +pub(crate) struct ClaimShape { + inputs: usize, + outputs: ReturnArity, +} + impl Block { + fn return_arity(&self) -> ReturnArity { + match &self.ctrl { + Ctrl::Return(_, values) => ReturnArity::Exact(values.len()), + Ctrl::Yield(..) => ReturnArity::NoReturns, + Ctrl::Match(_, branches, fallback) => branches + .values() + .chain(fallback.iter().map(Box::as_ref)) + .fold(ReturnArity::NoReturns, |arity, block| { + arity.merge(block.return_arity()) + }), + Ctrl::MatchContinue(_, branches, fallback, _, _, _, continuation) => { + branches + .values() + .chain(fallback.iter().map(Box::as_ref)) + .fold(continuation.return_arity(), |arity, block| { + arity.merge(block.return_arity()) + }) + }, + } + } + /// Every function return, including an early return from a continuation /// arm, has this output arity. Yields return to their own continuation. + /// Kept as an independent recursive reference for the cached summary. + #[cfg(test)] pub(crate) fn returns_have_size(&self, size: usize) -> bool { match &self.ctrl { Ctrl::Return(_, values) => values.len() == size, @@ -39,6 +93,7 @@ impl Block { fn check_lookup_shapes( &self, program: &Toplevel, + return_arities: &[ReturnArity], yield_size: Option, ) -> Result<(), &'static str> { for op in &self.ops { @@ -53,7 +108,7 @@ impl Block { if callee.layout.input_size != inputs.len() { return Err("constrained call input arity differs from its callee"); } - if !callee.body.returns_have_size(*outputs) { + if !return_arities[*index].accepts(*outputs) { return Err( "constrained call output arity differs from its callee", ); @@ -77,20 +132,24 @@ impl Block { }, Ctrl::Match(_, branches, fallback) => { for block in branches.values() { - block.check_lookup_shapes(program, yield_size)?; + block.check_lookup_shapes(program, return_arities, yield_size)?; } if let Some(block) = fallback { - block.check_lookup_shapes(program, yield_size)?; + block.check_lookup_shapes(program, return_arities, yield_size)?; } }, Ctrl::MatchContinue(_, branches, fallback, size, _, _, continuation) => { for block in branches.values() { - block.check_lookup_shapes(program, Some(*size))?; + block.check_lookup_shapes(program, return_arities, Some(*size))?; } if let Some(block) = fallback { - block.check_lookup_shapes(program, Some(*size))?; + block.check_lookup_shapes(program, return_arities, Some(*size))?; } - continuation.check_lookup_shapes(program, yield_size)?; + continuation.check_lookup_shapes( + program, + return_arities, + yield_size, + )?; }, } Ok(()) @@ -101,38 +160,70 @@ impl Toplevel { /// Check the static boundaries of all constrained function messages. /// This does not check value indices, layouts or arithmetic constraints. pub fn validate_lookup_shapes(&self) -> Result<(), &'static str> { + self.checked_claim_shapes().map(|_| ()) + } + + pub(crate) fn checked_claim_shapes( + &self, + ) -> Result>, &'static str> { if !canonical_size(self.functions.len()) { return Err("function index domain exceeds the field characteristic"); } if self.memory_sizes.iter().any(|&size| !canonical_size(size)) { return Err("memory width is not a canonical field element"); } + // Summarize each constrained body once, then reuse the result at every + // call site and public verification. Yields do not return from functions. + let return_arities: Vec<_> = self + .functions + .iter() + .map(|function| { + if function.constrained { + function.body.return_arity() + } else { + ReturnArity::NoReturns + } + }) + .collect(); for function in &self.functions { if function.constrained { - function.body.check_lookup_shapes(self, None)?; + function.body.check_lookup_shapes(self, &return_arities, None)?; } } - Ok(()) + Ok( + self + .functions + .iter() + .zip(return_arities) + .map(|(function, outputs)| { + (function.entry && function.constrained).then_some(ClaimShape { + inputs: function.layout.input_size, + outputs, + }) + }) + .collect(), + ) } +} - pub(crate) fn valid_claim_shape(&self, claim: &[G]) -> bool { - let [channel, index, arguments @ ..] = claim else { - return false; - }; - if *channel != function_channel() { - return false; - } - let Ok(index) = usize::try_from(index.as_canonical_u64()) else { - return false; - }; - let Some(function) = self.functions.get(index) else { - return false; - }; - function.entry - && function.constrained - && arguments.len() >= function.layout.input_size - && function - .body - .returns_have_size(arguments.len() - function.layout.input_size) +pub(crate) fn valid_claim_shape( + shapes: &[Option], + claim: &[G], +) -> bool { + let [channel, index, arguments @ ..] = claim else { + return false; + }; + if *channel != function_channel() { + return false; } + let Ok(index) = usize::try_from(index.as_canonical_u64()) else { + return false; + }; + let Some(Some(shape)) = shapes.get(index) else { + return false; + }; + arguments + .len() + .checked_sub(shape.inputs) + .is_some_and(|outputs| shape.outputs.accepts(outputs)) } diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 25b436d44..9607e7b8d 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -1,12 +1,14 @@ use multi_stark::{ + config::StarkGenericConfig, expr::Expr, - lookup::Lookup, - p3_field::PrimeCharacteristicRing, + lookup::{Lookup, LookupRowMut}, + p3_field::{BasedVectorSpace, PrimeCharacteristicRing}, p3_matrix::dense::RowMajorMatrix, prover::Proof, system::{CircuitInputs, ProverKey, System, SystemWitness}, types::{ - CommitmentParameters, FriParameters, GoldilocksBlake3Config, PcsError, + CommitmentParameters, ExtVal, FriParameters, GoldilocksBlake3Config, + PcsError, }, verifier::VerificationError, }; @@ -21,6 +23,7 @@ use crate::{ function_channel, gadgets::{AiurGadget, bytes1::Bytes1, bytes2::Bytes2}, lookup_budget::lookup_query_bound, + lookup_shapes::{ClaimShape, valid_claim_shape}, memory::Memory, trace_heights::{fixed_trace_heights, trace_cap_coverage}, }; @@ -45,7 +48,7 @@ pub struct PeakProveBytes { // Across the 168 completed Mathlib shard proofs at multi-stark 2892243e, // measured RSS / analytic peak had median 1.0678 and maximum under-prediction // 1.0714. A 7.5% envelope covers the full sample with a small margin. The -// workspace now pins a8aab731; retain this historical guard, but re-calibrate +// workspace now pins 9a906122; retain this historical guard, but re-calibrate // before treating it as a full-scale safety bound for the new prover. const PROVER_RSS_CALIBRATION_NUMERATOR: usize = 43; const PROVER_RSS_CALIBRATION_DENOMINATOR: usize = 40; @@ -76,6 +79,7 @@ pub enum GatedProve { pub struct AiurSystem { toplevel: Toplevel, + claim_shapes: Vec>, // 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 @@ -109,19 +113,26 @@ pub struct CircuitShape { pub preprocessed_height: usize, } -/// Raw row count of a circuit under `record`, ceil-divided into `parts` -/// even shares — `parts = 1` is the record's exact heights. The byte -/// gadgets keep their fixed heights: they are the same size in every +/// Conservative row count of a circuit under `record`, ceil-divided into +/// `parts` even shares. Sum member-function rows before dividing; circuit +/// indices are not function indices. Unlike witness generation, this count +/// includes zero-multiplicity hint rows. The byte gadgets keep their fixed +/// heights: they are the same size in every /// shard and are most of the peak model's floor, which dividing cannot /// shrink. -fn raw_of( - record: &QueryRecord, +fn raw_of<'a>( + toplevel: &'a Toplevel, + record: &'a QueryRecord, parts: usize, -) -> impl Fn(usize, &CircuitType) -> usize + '_ { +) -> impl Fn(usize, &CircuitType) -> usize + 'a { move |_, ct| match ct { - CircuitType::Function { idx } => { - record.function_queries[*idx].len().div_ceil(parts) - }, + CircuitType::Function { idx } => toplevel.circuits[*idx] + .members + .iter() + .fold(0usize, |rows, &member| { + rows.saturating_add(record.function_queries[member].len()) + }) + .div_ceil(parts), CircuitType::Memory { width } => { record.memory_queries.get(width).map_or(0, |m| m.len().div_ceil(parts)) }, @@ -136,7 +147,8 @@ impl AiurSystem { commitment_parameters: CommitmentParameters, fri_parameters: FriParameters, ) -> Self { - toplevel.validate_lookup_shapes().expect("invalid Aiur lookup shapes"); + let claim_shapes = + toplevel.checked_claim_shapes().expect("invalid Aiur lookup shapes"); toplevel.validate_row_counts().expect("invalid Aiur control counts"); let mut circuit_inputs: Vec> = Vec::new(); let mut slot_widths: Vec> = Vec::new(); @@ -164,9 +176,9 @@ impl AiurSystem { // A branchless circuit's lookup arguments are sent raw (degree 1; // see `ConstraintState::gate`), so two lookups fit in one chained // accumulator step at degree 3 — within the degree the selector-gated - // constraints already pay for. Branching circuits keep k = 1: their - // superposed arguments are degree 2, and grouping would push the - // logUp constraints past the quotient budget. + // constraints already pay for. This is the conservative baseline; + // after compilation, retune against actual message degrees and the + // configured quotient budget, including the FFT cost of raising it. let group_size = if toplevel.circuit_is_branchless(i) && lookups.len() >= 2 { 2 @@ -189,7 +201,7 @@ impl AiurSystem { // Gadgets. The byte chips' lookup arguments are preprocessed columns // and their multiplicities main columns (all degree 1), so their // lookups also group 2 per chained step at degree 3 — halving the - // stage-2 accumulators (Bytes2: 10 → 5 at height 65536). + // stage-2 accumulators (Bytes2: 8 → 4 at height 65536). push_circuit( Bytes1.main_width(), Bytes1.preprocessed(), @@ -206,11 +218,20 @@ impl AiurSystem { ); let config = AiurConfig::new(commitment_parameters, fri_parameters); - let (system, key) = System::new(config, circuit_inputs); + let (mut system, key) = System::new(config, circuit_inputs); + let blowup = system.config.max_quotient_degree(); + for circuit in &mut system.circuits { + crate::lookup_groups::retune( + circuit, + blowup, + >::DIMENSION, + ); + } AiurSystem { system, key, toplevel, + claim_shapes, commitment_parameters, fri_parameters, slot_widths, @@ -261,7 +282,7 @@ impl AiurSystem { /// Predicted peak prover resident bytes for a record, from circuit /// shapes alone — the analytic counterpart of an empirical GiB-per-fft /// line. The terms mirror the allocation schedule originally calibrated at - /// multi-stark rev `2892243e`. The workspace now pins `a8aab731`, so the + /// multi-stark rev `2892243e`. The workspace now pins `9a906122`, so the /// model remains useful for relative shard sizing but needs a measured /// full-scale re-calibration before its absolute bound is relied upon: /// @@ -284,7 +305,7 @@ impl AiurSystem { /// which per-fft models blur. pub fn peak_prove_bytes(&self, record: &QueryRecord) -> PeakProveBytes { self.peak_prove_bytes_by( - raw_of(record, 1), + raw_of(&self.toplevel, record, 1), crate::execute::record_retained_bytes(record), ) } @@ -321,11 +342,21 @@ impl AiurSystem { } let n = raw.next_power_of_two(); let c = &self.system.circuits[i]; - let d = c.stage_2_width / (1 + c.num_lookups); // extension degree + // Grouped accumulator width does not determine the extension degree. + let d = >::DIMENSION; let args: usize = self.slot_widths[i].iter().sum(); let q = c.quotient_degree(); - witness += - S * n * c.main_width + S * n * (c.num_lookups + args) + 40 * raw; + let metadata = match ct { + CircuitType::Function { idx } => crate::trace::witness_metadata_bytes( + self.toplevel.circuits[*idx].members.len(), + raw, + ), + _ => 0, + }; + witness += S * n * c.main_width + + S * n * (c.num_lookups + args) + + size_of::>() * n + + metadata; s1_lde += S * b * n * c.main_width; lookup_w += S * n * (c.num_lookups + args); msgs += 2 * S * d * n * c.num_lookups; @@ -375,7 +406,10 @@ impl AiurSystem { // count; stop rather than search forever. while parts < (1 << 20) { let peak = self - .peak_prove_bytes_by(raw_of(record, parts), record_bytes / parts) + .peak_prove_bytes_by( + raw_of(&self.toplevel, record, parts), + record_bytes / parts, + ) .peak; if peak <= max_bytes { break; @@ -578,7 +612,7 @@ impl AiurSystem { claim: &[G], proof: &AiurProof, ) -> Result<(), VerificationError> { - if !self.toplevel.valid_claim_shape(claim) { + if !valid_claim_shape(&self.claim_shapes, claim) { return Err(VerificationError::InvalidClaim); } if !fixed_trace_heights( @@ -623,10 +657,15 @@ impl AiurSystem { mod tests { mod acceptance; mod branchless; + mod byte_consolidation; mod byte_shapes; + mod host_timings; mod lookup_budget; + mod lookup_groups; mod lookup_shapes; mod mmcs; + mod peak; + mod u32_compare; use super::*; use crate::{ @@ -1018,7 +1057,7 @@ mod tests { // height doubles as the committed trace height. assert_eq!(shapes[3].preprocessed_width, 11); assert_eq!(shapes[3].preprocessed_height, 256); - assert_eq!(shapes[4].preprocessed_width, 14); + assert_eq!(shapes[4].preprocessed_width, 11); assert_eq!(shapes[4].preprocessed_height, 65536); } } diff --git a/crates/aiur/src/synthesis/tests/byte_consolidation.rs b/crates/aiur/src/synthesis/tests/byte_consolidation.rs new file mode 100644 index 000000000..3ab831dd9 --- /dev/null +++ b/crates/aiur/src/synthesis/tests/byte_consolidation.rs @@ -0,0 +1,325 @@ +// Copyright (c) 2026 Argument Computer Corporation. +// SPDX-License-Identifier: MIT OR Apache-2.0 + +use super::*; +use crate::{ + execute::{ + QueryRecord, bytes2_and_value, bytes2_less_than_value, bytes2_or_value, + }, + gadgets::bytes2::Bytes2Op, +}; +use multi_stark::eval::{VarValues, eval_expr}; + +fn byte_toplevel(grouped: bool) -> Toplevel { + let functions = [Op::U8And(0, 1), Op::U8Or(0, 1), Op::U8LessThan(0, 1)] + .into_iter() + .map(|op| Function { + body: Block { ops: vec![op], ctrl: Ctrl::Return(0, vec![2]) }, + layout: FunctionLayout { + input_size: 2, + selectors: 1, + auxiliaries: 2, + lookups: 2, + }, + entry: true, + constrained: true, + }) + .collect(); + let mut top = with_singleton_circuits(functions, vec![]); + if grouped { + top.circuits = vec![crate::bytecode::Circuit { + members: vec![0, 1, 2], + layout: FunctionLayout { + input_size: 2, + selectors: 3, + auxiliaries: 2, + lookups: 2, + }, + }]; + } + top +} + +fn values<'a>(row: &'a [G], preprocessed: &'a [G]) -> VarValues<'a, G> { + VarValues { + preprocessed: [preprocessed, preprocessed], + main: [row, row], + stage2: [&[], &[]], + publics: &[], + is_first_row: G::ONE, + is_last_row: G::ZERO, + is_transition: G::ONE, + } +} + +fn message(lookup: &Lookup>, row: &[G], preprocessed: &[G]) -> Vec { + let vars = values(row, preprocessed); + lookup.args.iter().map(|arg| eval_expr(arg, &vars)).collect() +} + +#[test] +fn every_byte_pair_matches_the_consolidated_compiled_lookup() { + let table = Bytes2.preprocessed().unwrap(); + let pulls = Bytes2.lookups(); + let table_row = [G::ZERO; 8]; + assert_eq!(table.width, 11); + assert_eq!(pulls.len(), 8); + + for grouped in [false, true] { + let top = byte_toplevel(grouped); + for member in 0..3 { + let circuit = if grouped { 0 } else { member }; + let layout = top.circuits[circuit].layout; + let (constraints, lookups) = top.build_constraints(circuit); + let pull = if member == 2 { 2 } else { 0 }; + assert_eq!(lookups.len(), 2); + assert_eq!(constraints.width, 2 + layout.selectors + 2); + let mut row = vec![G::ZERO; constraints.width]; + row[2 + if grouped { member } else { 0 }] = G::ONE; + row[2 + layout.selectors] = G::ONE; + let output_column = 3 + layout.selectors; + for a in 0..=u8::MAX { + for b in 0..=u8::MAX { + let expected = match member { + 0 => G::from_u8(a & b), + 1 => G::from_u8(a | b), + _ => G::from_bool(a < b), + }; + row[0] = G::from_u8(a); + row[1] = G::from_u8(b); + row[output_column] = expected; + let preprocessed = &table.values + [(usize::from(a) * 256 + usize::from(b)) * table.width..] + [..table.width]; + let provider = message(&pulls[pull], &table_row, preprocessed); + assert_eq!(message(&lookups[1], &row, &[]), provider); + assert!( + constraints + .zeros + .iter() + .all(|c| { eval_expr(c, &values(&row, &[])) == G::ZERO }) + ); + // Test the actual field equations against out-of-range and wrong + // results, not just host-byte arithmetic. Nonzero coefficients + // make the correct result the unique solution in the field. + for wrong in [-G::ONE, G::from_u16(256), expected + G::ONE] { + row[output_column] = wrong; + assert_ne!(message(&lookups[1], &row, &[]), provider); + } + } + } + // Inactive rows, including grouped members, send no requests even + // when their unused inputs/output contain arbitrary field values. + row.fill(-G::ONE); + row[2..3 + layout.selectors].fill(G::ZERO); + assert!( + constraints + .zeros + .iter() + .all(|c| { eval_expr(c, &values(&row, &[])) == G::ZERO }) + ); + assert!(lookups.iter().all(|lookup| { + eval_expr(&lookup.multiplicity, &values(&row, &[])) == G::ZERO + })); + } + } +} + +#[test] +fn interpreter_and_generated_helpers_share_table_multiplicities() { + let top = byte_toplevel(false); + let mut interpreted = QueryRecord::new(&top); + let mut generated = QueryRecord::new(&top); + for a in 0..=u8::MAX { + for b in 0..=u8::MAX { + let x = G::from_u8(a); + let y = G::from_u8(b); + let expected = + [G::from_u8(a & b), G::from_u8(a | b), G::from_bool(a < b)]; + let got = [ + bytes2_and_value(x, y, &mut generated), + bytes2_or_value(x, y, &mut generated), + bytes2_less_than_value(x, y, &mut generated), + ]; + assert_eq!(got, expected); + for (op, expected) in + [Bytes2Op::And, Bytes2Op::Or, Bytes2Op::LessThan].iter().zip(expected) + { + assert_eq!(Bytes2.execute(op, &[x, y], &mut interpreted), [expected]); + } + } + } + let widths: Vec<_> = Bytes2.lookups().iter().map(|l| l.args.len()).collect(); + let (a, _) = Bytes2.witness_data(&interpreted, &widths); + let (b, _) = Bytes2.witness_data(&generated, &widths); + assert_eq!(a.values, b.values); + for row in a.values.chunks_exact(a.width) { + assert_eq!( + row, + [G::TWO, G::ZERO, G::ONE, G::ZERO, G::ZERO, G::ZERO, G::ZERO, G::ZERO] + ); + } +} + +#[test] +fn consolidated_byte_proofs_verify_in_both_partitions_and_key_codec() { + for grouped in [false, true] { + let (mut cp, fp) = test_parameters(); + cp.log_blowup = 2; + let system = AiurSystem::build(byte_toplevel(grouped), cp, fp); + let shape = system.circuit_shapes().pop().unwrap(); + assert_eq!( + ( + shape.main_width, + shape.stage2_width, + shape.quotient_degree, + shape.preprocessed_width, + shape.preprocessed_height + ), + (8, 8, 2, 11, 65_536) + ); + let bytes = crate::vk_codec::aiur_system_to_bytes(&system).unwrap(); + let (decoded, _, _) = crate::vk_codec::from_bytes(&bytes).unwrap(); + for member in 0..3 { + for (a, b) in [(0xd3_u8, 0x69_u8), (0, 255)] { + let input = [G::from_u8(a), G::from_u8(b)]; + let expected = match member { + 0 => G::from_u8(a & b), + 1 => G::from_u8(a | b), + _ => G::from_bool(a < b), + }; + let (claim, proof) = + system.prove(member, &input, &mut empty_io_buffer()); + assert_eq!(claim.last(), Some(&expected)); + system.verify(&claim, &proof).unwrap(); + decoded.verify(&claim, &proof).unwrap(); + } + } + } +} + +/// Supply the stage-one trace directly after changing the claimed output +/// or a byte input. Local constraints still hold; the fixed lookup table +/// must reject the false relation, including through grouped selectors. +#[test] +fn forged_consolidated_outputs_and_nonbyte_inputs_fail_lookup_verification() { + for grouped in [false, true] { + let (cp, fp) = test_parameters(); + let system = AiurSystem::build(byte_toplevel(grouped), cp, fp); + let input = [G::from_u8(3), G::from_u8(5)]; + for member in 0..3 { + let circuit = if grouped { 0 } else { member }; + let layout = system.toplevel.circuits[circuit].layout; + let (record, output) = system + .toplevel + .execute(member, input.to_vec(), &mut empty_io_buffer()) + .unwrap(); + let mut original = Vec::new(); + for i in 0..system.toplevel.circuits.len() { + let (trace, _) = system.toplevel.witness_data( + i, + &record, + &empty_io_buffer(), + &system.slot_arg_widths(i), + ); + original.push(trace); + } + original.push( + Bytes1.witness_data(&record, &system.slot_arg_widths(original.len())).0, + ); + original.push( + Bytes2.witness_data(&record, &system.slot_arg_widths(original.len())).0, + ); + let (constraints, _) = system.toplevel.build_constraints(circuit); + for (column, claimed_input, claimed_output) in [ + (3 + layout.selectors, input, -G::ONE), + (0, [G::from_u16(256), input[1]], output[0]), + ] { + let mut traces = original.clone(); + traces[circuit].values[column] = + if column == 0 { claimed_input[0] } else { claimed_output }; + let row = &traces[circuit].values[..layout.width()]; + assert!( + constraints + .zeros + .iter() + .all(|c| { eval_expr(c, &values(row, &[])) == G::ZERO }) + ); + let claim = vec![ + function_channel(), + G::from_usize(member), + claimed_input[0], + claimed_input[1], + claimed_output, + ]; + let witness = SystemWitness::from_stage_1(traces, &system.system); + let proof = system.system.prove(&system.key, &claim, witness); + assert!(system.verify(&claim, &proof).is_err()); + } + } + } +} + +#[test] +fn original_and_consolidated_operations_share_multiplicities_in_one_proof() { + let function = Function { + body: Block { + ops: vec![ + Op::U8And(0, 1), + Op::U8Or(0, 1), + Op::U8LessThan(0, 1), + Op::U8Xor(0, 1), + Op::U8Sub(0, 1), + ], + ctrl: Ctrl::Return(0, vec![2, 3, 4, 5, 6, 7]), + }, + layout: FunctionLayout { + input_size: 2, + selectors: 1, + auxiliaries: 6, + lookups: 6, + }, + entry: true, + constrained: true, + }; + let top = with_singleton_circuits(vec![function], vec![]); + let (cp, fp) = test_parameters(); + let system = AiurSystem::build(top, cp, fp); + for (a, b) in [(0_u8, 255_u8), (255, 0), (0xd3, 0x69), (255, 255)] { + let input = [G::from_u8(a), G::from_u8(b)]; + let mut io = empty_io_buffer(); + let (record, output) = + system.toplevel.execute(0, input.to_vec(), &mut io).unwrap(); + let (sub, borrow) = a.overflowing_sub(b); + assert_eq!( + output, + [ + G::from_u8(a & b), + G::from_u8(a | b), + G::from_bool(a < b), + G::from_u8(a ^ b), + G::from_u8(sub), + G::from_bool(borrow), + ] + ); + let (table, _) = Bytes2.witness_data(&record, &system.slot_arg_widths(2)); + let row = &table.values + [(usize::from(a) * 256 + usize::from(b)) * table.width..][..table.width]; + assert_eq!( + row, + [ + G::from_u8(3), + G::ZERO, + G::TWO, + G::ZERO, + G::ZERO, + G::ZERO, + G::ZERO, + G::ZERO + ] + ); + let (claim, proof) = + system.prove_from_execution(0, &input, &io, record, &output); + system.verify(&claim, &proof).unwrap(); + } +} diff --git a/crates/aiur/src/synthesis/tests/host_timings.rs b/crates/aiur/src/synthesis/tests/host_timings.rs new file mode 100644 index 000000000..fbbc90429 --- /dev/null +++ b/crates/aiur/src/synthesis/tests/host_timings.rs @@ -0,0 +1,55 @@ +// Copyright (c) 2026 Argument Computer Corporation. +// SPDX-License-Identifier: MIT OR Apache-2.0 + +use super::*; + +/// Run the same fixture in separate processes at the old and new revisions +/// to compare peak RSS. Construction and record allocation are outside the +/// timer; no proof is needed to measure witness generation. No timing pin. +#[test] +#[ignore = "manual witness construction memory and timing measurement"] +fn witness_construction_timings() { + use std::{hint::black_box, time::Instant}; + + let n: usize = std::env::var("AIUR_WITNESS_ROWS") + .unwrap_or_else(|_| "1048576".into()) + .parse() + .expect("positive row count"); + assert!(n > 0); + let function = Function { + body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }, + layout: FunctionLayout { + input_size: 1, + selectors: 1, + auxiliaries: 1, + lookups: 1, + }, + entry: true, + constrained: true, + }; + let top = with_singleton_circuits(vec![function], vec![]); + let (cp, fp) = test_parameters(); + let system = AiurSystem::build(top, cp, fp); + let mut record = QueryRecord::new(&system.toplevel); + for value in 0..n { + let value = G::from_usize(value); + record.function_queries[0].insert(&[value], &[value], G::ONE); + } + let start = Instant::now(); + let (trace, lookups) = system.toplevel.witness_data( + 0, + &record, + &empty_io_buffer(), + &system.slot_widths[0], + ); + let elapsed = start.elapsed(); + assert_eq!(trace.values.len(), n.next_power_of_two() * 3); + assert_eq!(&trace.values[..3], &[G::ZERO, G::ONE, G::ONE]); + assert_eq!(trace.values[(n - 1) * 3], G::from_usize(n - 1)); + black_box((&trace, &lookups)); + eprintln!( + "rows={n} metadata_bytes={} witness_ms={:.3}", + crate::trace::witness_metadata_bytes(1, n), + elapsed.as_secs_f64() * 1_000.0 + ); +} diff --git a/crates/aiur/src/synthesis/tests/lookup_groups.rs b/crates/aiur/src/synthesis/tests/lookup_groups.rs new file mode 100644 index 000000000..b2caa47fb --- /dev/null +++ b/crates/aiur/src/synthesis/tests/lookup_groups.rs @@ -0,0 +1,140 @@ +// Copyright (c) 2026 Argument Computer Corporation. +// SPDX-License-Identifier: MIT OR Apache-2.0 + +use super::*; + +/// f(n) = 16*n*n + f(n-1), with sixteen shared calls to g(n) = n*n. +/// Its gated lookup messages benefit from k = 2 at quotient degree 4. +fn wide_recursive_toplevel() -> Toplevel { + let mut ops: Vec<_> = + (0..16).map(|_| Op::Call(1, vec![0], 1, false)).collect(); + ops.extend([ + Op::Const(G::ONE), + Op::Sub(0, 17), + Op::Call(0, vec![18], 1, false), + ]); + let mut sum = 1; + for value in 2..=16 { + ops.push(Op::Add(sum, value)); + sum = ops.len(); + } + ops.push(Op::Add(sum, 19)); + let root = Function { + body: Block { + ops: vec![], + ctrl: Ctrl::Match( + 0, + [( + G::ZERO, + Block { + ops: vec![Op::Const(G::ZERO)], + ctrl: Ctrl::Return(0, vec![1]), + }, + )] + .into_iter() + .collect(), + Some(Box::new(Block { ops, ctrl: Ctrl::Return(1, vec![35]) })), + ), + }, + layout: FunctionLayout { + input_size: 1, + selectors: 2, + auxiliaries: 19, + lookups: 18, + }, + entry: true, + constrained: true, + }; + let leaf = Function { + body: Block { ops: vec![Op::Mul(0, 0)], ctrl: Ctrl::Return(0, vec![1]) }, + layout: FunctionLayout { + input_size: 1, + selectors: 1, + auxiliaries: 2, + lookups: 1, + }, + entry: false, + constrained: true, + }; + with_singleton_circuits(vec![root, leaf], vec![]) +} + +fn wide_system(log_blowup: usize) -> AiurSystem { + let (mut cp, fp) = test_parameters(); + cp.log_blowup = log_blowup; + AiurSystem::build(wide_recursive_toplevel(), cp, fp) +} + +#[test] +fn larger_lookup_groups_verify_and_roundtrip_with_the_degree_budget() { + for (log_blowup, group, quotient, stage2) in [(1, 1, 2, 36), (2, 2, 4, 18)] { + let system = wide_system(log_blowup); + let circuit = &system.system.circuits[0]; + assert_eq!(circuit.lookup_group_size, group); + assert_eq!(circuit.quotient_degree(), quotient); + assert_eq!(circuit.stage_2_width, stage2); + assert!(system.system.circuits.iter().all(|c| { + c.quotient_degree() <= system.system.config.max_quotient_degree() + })); + // Grouping changes accumulator count, never the logical message count + // used by the characteristic bound on lookup consumers. + assert_eq!(system.slot_widths[0].len(), 18); + assert_eq!( + lookup_query_bound( + system.slot_widths.iter().map(Vec::len), + &[true, false, false, false], + &[3], + ), + Some(1 + 18 * 8) + ); + let bytes = crate::vk_codec::aiur_system_to_bytes(&system).unwrap(); + let (decoded, cp, fp) = crate::vk_codec::from_bytes(&bytes).unwrap(); + assert_eq!(crate::vk_codec::to_bytes(&decoded, cp, fp), bytes); + let back = &decoded.circuits[0]; + assert_eq!(back.lookup_group_size, group); + assert_eq!(back.max_constraint_degree, circuit.max_constraint_degree); + assert_eq!(back.constraint_count, circuit.constraint_count); + assert_eq!(back.stage_2_width, circuit.stage_2_width); + for n in [0_u8, 7] { + let (mut claim, proof) = + system.prove(0, &[G::from_u8(n)], &mut empty_io_buffer()); + let expected: u64 = (1..=u64::from(n)).map(|i| 16 * i * i).sum(); + assert_eq!(claim.last(), Some(&G::from_u64(expected))); + system.verify(&claim, &proof).unwrap(); + decoded.verify(&claim, &proof).unwrap(); + *claim.last_mut().unwrap() += G::ONE; + assert!(system.verify(&claim, &proof).is_err()); + assert!(decoded.verify(&claim, &proof).is_err()); + } + } +} + +/// An opt-in wall-clock check for the quotient-work/FFT tradeoff. Timings +/// exclude construction and verification; both configurations use identical +/// bytecode, commitment parameters and query workloads. No timing assertion. +#[test] +#[ignore = "manual lookup grouping performance comparison"] +fn lookup_group_proving_timings() { + use std::time::Instant; + + let grouped = wide_system(2); + let mut legacy = wide_system(2); + crate::lookup_groups::set_group(&mut legacy.system.circuits[0], 1, 2); + for n in [7, 32_768, 131_072] { + for round in 0..3 { + for pick in 0..2 { + let (name, system) = if (round + pick) % 2 == 0 { + ("legacy", &legacy) + } else { + ("grouped", &grouped) + }; + let start = Instant::now(); + let (claim, proof) = + system.prove(0, &[G::from_u32(n)], &mut empty_io_buffer()); + let elapsed = start.elapsed(); + system.verify(&claim, &proof).unwrap(); + println!("lookup timing: n={n} round={round} {name} {elapsed:?}"); + } + } + } +} diff --git a/crates/aiur/src/synthesis/tests/lookup_shapes.rs b/crates/aiur/src/synthesis/tests/lookup_shapes.rs index 9613ed941..f3fcbec1e 100644 --- a/crates/aiur/src/synthesis/tests/lookup_shapes.rs +++ b/crates/aiur/src/synthesis/tests/lookup_shapes.rs @@ -66,7 +66,11 @@ fn system_construction_rejects_mismatched_call_outputs() { #[test] fn public_claim_shape_checks_channel_visibility_and_arity() { let top = mul_toplevel(); - assert!(top.valid_claim_shape(&[G::ZERO, G::ZERO, G::ONE, G::ONE, G::ONE])); + let shapes = top.checked_claim_shapes().unwrap(); + assert!(valid_claim_shape( + &shapes, + &[G::ZERO, G::ZERO, G::ONE, G::ONE, G::ONE] + )); for claim in [ vec![], vec![G::ZERO], @@ -76,13 +80,16 @@ fn public_claim_shape_checks_channel_visibility_and_arity() { vec![G::ZERO, G::ZERO, G::ONE, G::ONE], vec![G::ZERO, G::ZERO, G::ONE, G::ONE, G::ONE, G::ZERO], ] { - assert!(!top.valid_claim_shape(&claim)); + assert!(!valid_claim_shape(&shapes, &claim)); } for constrained in [true, false] { let mut top = mul_toplevel(); top.functions[0].entry = !constrained; top.functions[0].constrained = constrained; - assert!(!top.valid_claim_shape(&[G::ZERO; 5])); + assert!(!valid_claim_shape( + &top.checked_claim_shapes().unwrap(), + &[G::ZERO; 5] + )); } } @@ -109,6 +116,77 @@ fn constrained_calls_check_both_message_boundaries() { top.validate_lookup_shapes().unwrap(); } +#[test] +fn cached_arities_match_recursive_checks_for_nested_control_flow() { + fn returning(size: usize) -> Block { + Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0; size]) } + } + fn yielding() -> Block { + Block { ops: vec![], ctrl: Ctrl::Yield(0, vec![0; 2]) } + } + fn matching(arms: Vec, fallback: Option) -> Block { + Block { + ops: vec![], + ctrl: Ctrl::Match( + 0, + arms + .into_iter() + .enumerate() + .map(|(i, b)| (G::from_usize(i), b)) + .collect(), + fallback.map(Box::new), + ), + } + } + fn continued(arm: Block, continuation: Block) -> Block { + Block { + ops: vec![], + ctrl: Ctrl::MatchContinue( + 0, + [(G::ZERO, arm)].into_iter().collect(), + Some(Box::new(yielding())), + 2, + 0, + 0, + Box::new(continuation), + ), + } + } + let mut bodies = vec![ + matching(vec![], None), + matching(vec![], Some(returning(0))), + continued(yielding(), matching(vec![], None)), + ]; + for a in 0..3 { + bodies.push(returning(a)); + bodies.push(continued(yielding(), returning(a))); + bodies.push(continued(continued(returning(a), yielding()), returning(a))); + for b in 0..3 { + bodies.push(matching(vec![returning(a), returning(b)], None)); + bodies.push(matching(vec![returning(a)], Some(returning(b)))); + bodies.push(continued(returning(a), returning(b))); + bodies.push(continued(continued(returning(a), yielding()), returning(b))); + } + } + for body in bodies { + let mut top = call_and_memory_toplevel(); + // Test the cached public boundary and each call-site boundary against + // the original recursive predicate, including vacuous and mixed returns. + top.functions[0].body.ops.clear(); + top.functions[1].entry = true; + top.functions[1].body = body; + let shapes = top.checked_claim_shapes().unwrap(); + for outputs in 0..4 { + let expected = top.functions[1].body.returns_have_size(outputs); + let mut claim = vec![function_channel(), G::ONE, G::ZERO]; + claim.resize(3 + outputs, G::ZERO); + assert_eq!(valid_claim_shape(&shapes, &claim), expected); + top.functions[0].body.ops = vec![Op::Call(1, vec![0], outputs, false)]; + assert_eq!(top.validate_lookup_shapes().is_ok(), expected); + } + } +} + #[test] fn nested_continuations_check_returns_and_yields() { fn returning(size: usize) -> Block { diff --git a/crates/aiur/src/synthesis/tests/peak.rs b/crates/aiur/src/synthesis/tests/peak.rs new file mode 100644 index 000000000..14d4a4fa2 --- /dev/null +++ b/crates/aiur/src/synthesis/tests/peak.rs @@ -0,0 +1,137 @@ +// Copyright (c) 2026 Argument Computer Corporation. +// SPDX-License-Identifier: MIT OR Apache-2.0 + +use super::*; +use crate::bytecode::Circuit; + +fn grouped_system() -> AiurSystem { + let layout = + FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 1, lookups: 1 }; + let functions = (0..3) + .map(|_| Function { + body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }, + layout, + entry: true, + constrained: true, + }) + .collect(); + let top = Toplevel { + functions, + memory_sizes: vec![1], + circuits: vec![ + Circuit { + members: vec![2, 0], + layout: FunctionLayout { selectors: 2, ..layout }, + }, + Circuit { members: vec![1], layout }, + ], + }; + let (cp, fp) = test_parameters(); + AiurSystem::build(top, cp, fp) +} + +fn grouped_record(top: &Toplevel) -> QueryRecord { + let mut record = QueryRecord::new(top); + for (i, rows) in [2, 3, 5].into_iter().enumerate() { + for row in 0..rows { + let value = G::from_usize(10 * i + row); + // An advice-only entry in the middle must not shift query indices + // or selectors of the surrounding active rows. + let mult = G::from_bool(i != 2 || row != 1); + record.function_queries[i].insert(&[value], &[value], mult); + } + } + record.memory_queries.get_mut(&1).unwrap().insert( + &[G::ONE], + &[G::ZERO], + G::ONE, + ); + record +} + +#[test] +fn grouped_peak_counts_members_before_splitting_and_keeps_gadget_heights() { + let system = grouped_system(); + let record = grouped_record(&system.toplevel); + let types = system.circuit_types(); + for (parts, expected) in + [(1, vec![7, 3, 1, 256, 65_536]), (4, vec![2, 1, 1, 256, 65_536])] + { + let counts: Vec<_> = types + .iter() + .enumerate() + .map(|(i, ct)| raw_of(&system.toplevel, &record, parts)(i, ct)) + .collect(); + assert_eq!(counts, expected); + } + let expected = system.peak_prove_bytes_by( + |i, _| [7, 3, 1, 256, 65_536][i], + crate::execute::record_retained_bytes(&record), + ); + assert_eq!(system.peak_prove_bytes(&record).peak, expected.peak); + assert_eq!(system.suggested_split_parts(&record, expected.peak), 1); + let half_peak = system.peak_prove_bytes_by( + |i, _| [4, 2, 1, 256, 65_536][i], + crate::execute::record_retained_bytes(&record) / 2, + ); + assert!(half_peak.peak < expected.peak); + assert_eq!(system.suggested_split_parts(&record, half_peak.peak), 2); +} + +#[test] +fn peak_uses_extension_storage_even_when_accumulators_are_grouped() { + let system = grouped_system(); + let peak = system.peak_prove_bytes_by(|_, _| 8, 0); + let circuits = &system.system.circuits; + assert!(circuits.iter().any(|c| c.lookup_group_size > 1)); + // Sum actual payload types: messages and their inverse copy are extension + // values regardless of how many accumulator columns are committed. + let expected: usize = circuits + .iter() + .zip(&system.slot_widths) + .map(|(c, widths)| { + 2 * 8 * c.main_width * size_of::() + + 8 * (c.num_lookups + widths.iter().sum::()) * size_of::() + + 2 * 8 * c.num_lookups * size_of::() + + 8 * c.stage_2_width * size_of::() + }) + .sum(); + assert_eq!(peak.phase_stage2, expected + 2 * 32 * 16); + // FRI retains base-coordinate LDEs plus extension-valued quotients. + let committed: usize = circuits + .iter() + .map(|c| { + 16 * ((c.main_width + c.stage_2_width) * size_of::() + + c.quotient_degree() * size_of::()) + }) + .sum(); + assert_eq!( + peak.phase_open, + committed + 3 * 2 * 32 * 16 + (2 * 8 + 2 * 32) * 16 * 2 + 11 * 8 * 16 + ); +} + +#[test] +fn grouped_witness_skips_advice_without_shifting_members() { + let system = grouped_system(); + let record = grouped_record(&system.toplevel); + let (trace, _) = system.toplevel.witness_data( + 0, + &record, + &empty_io_buffer(), + &system.slot_widths[0], + ); + assert_eq!(trace.values.len(), 8 * trace.width); + for (row, (member, query)) in + [(2, 0), (2, 2), (2, 3), (2, 4), (0, 0), (0, 1)].into_iter().enumerate() + { + let values = &trace.values[row * trace.width..(row + 1) * trace.width]; + assert_eq!(values[0], G::from_usize(10 * member + query)); + assert_eq!( + &values[1..3], + &[G::from_bool(member == 2), G::from_bool(member == 0)] + ); + assert_eq!(values[3], G::ONE); + } + assert!(trace.values[6 * trace.width..].iter().all(|&v| v == G::ZERO)); +} diff --git a/crates/aiur/src/synthesis/tests/u32_compare.rs b/crates/aiur/src/synthesis/tests/u32_compare.rs new file mode 100644 index 000000000..463fbfeda --- /dev/null +++ b/crates/aiur/src/synthesis/tests/u32_compare.rs @@ -0,0 +1,377 @@ +// Copyright (c) 2026 Argument Computer Corporation. +// SPDX-License-Identifier: MIT OR Apache-2.0 + +use super::*; +use crate::bytecode::Circuit; +use multi_stark::{ + eval::{VarValues, eval_expr}, + p3_field::PrimeField64, +}; + +fn comparison_toplevel(grouped: bool) -> Toplevel { + let layout = + FunctionLayout { input_size: 2, selectors: 1, auxiliaries: 7, lookups: 7 }; + let functions = (0..2) + .map(|_| Function { + body: Block { + ops: vec![Op::U32LessThan(0, 1)], + ctrl: Ctrl::Return(0, vec![2]), + }, + layout, + entry: true, + constrained: true, + }) + .collect(); + let mut top = with_singleton_circuits(functions, vec![]); + if grouped { + top.circuits = vec![Circuit { + members: vec![0, 1], + layout: FunctionLayout { selectors: 2, ..layout }, + }]; + } + top +} + +fn values<'a>(row: &'a [G], preprocessed: &'a [G]) -> VarValues<'a, G> { + VarValues { + preprocessed: [preprocessed, preprocessed], + main: [row, row], + stage2: [&[], &[]], + publics: &[], + is_first_row: G::ONE, + is_last_row: G::ZERO, + is_transition: G::ONE, + } +} + +fn message(lookup: &Lookup>, row: &[G], pre: &[G]) -> Vec { + let vars = values(row, pre); + lookup.args.iter().map(|arg| eval_expr(arg, &vars)).collect() +} + +fn honest_row( + layout: FunctionLayout, + selector: usize, + a: u32, + b: u32, +) -> Vec { + let mut row = vec![G::ZERO; layout.width()]; + row[0] = G::from_u32(a); + row[1] = G::from_u32(b); + row[2 + selector] = G::ONE; + let aux = 2 + layout.selectors; + row[aux] = G::ONE; + let start = aux + 1; + let c = a.wrapping_sub(b); + for (i, word) in [a, c, b].into_iter().enumerate() { + row[start + 2 * i] = G::from_u16((word & 0xffff) as u16); + row[start + 2 * i + 1] = G::from_u16((word >> 16) as u16); + } + row +} + +#[test] +fn u32_compare_all_six_limbs_match_the_scalar_table_in_both_partitions() { + let table = Bytes2.preprocessed().unwrap(); + let providers = Bytes2.lookups(); + let table_row = [G::ZERO; 8]; + for grouped in [false, true] { + let top = comparison_toplevel(grouped); + for member in 0..2 { + let circuit = if grouped { 0 } else { member }; + let layout = top.circuits[circuit].layout; + let (constraints, requests) = top.build_constraints(circuit); + assert_eq!(requests.len(), 7); + assert_eq!(constraints.width, 9 + layout.selectors); + let start = 3 + layout.selectors; + let mut row = honest_row(layout, if grouped { member } else { 0 }, 0, 0); + for value in 0..=u16::MAX { + let field = G::from_u16(value); + row[start..start + 6].fill(field); + let pre = + &table.values[usize::from(value) * table.width..][..table.width]; + let provider = + message(&providers[Bytes2::U16_RANGE_CHECK_COLUMN], &table_row, pre); + assert_eq!(provider, [crate::u16_range_check_channel(), field]); + for request in &requests[1..] { + assert_eq!(message(request, &row, &[]), provider); + assert_eq!( + eval_expr(&request.multiplicity, &values(&row, &[])), + G::ONE + ); + } + } + for limb in 0..6 { + for bad in [-G::ONE, G::from_u32(65536), G::from_u64(1 << 32)] { + row[start + limb] = bad; + assert_eq!( + message(&requests[1 + limb], &row, &[]), + [crate::u16_range_check_channel(), bad] + ); + assert!(bad.as_canonical_u64() > u64::from(u16::MAX)); + } + } + } + } +} + +#[test] +fn u32_compare_constraints_preserve_strictness_bounds_and_inactive_gates() { + let boundary = [ + 0_u32, + 1, + 255, + 256, + 65535, + 65536, + 65537, + 0x7fff_ffff, + 0x8000_0000, + 0xffff_0000, + 0xffff_fffe, + u32::MAX, + ]; + for grouped in [false, true] { + let top = comparison_toplevel(grouped); + for member in 0..2 { + let circuit = if grouped { 0 } else { member }; + let layout = top.circuits[circuit].layout; + let (constraints, requests) = top.build_constraints(circuit); + for a in boundary { + for b in boundary { + let row = honest_row(layout, if grouped { member } else { 0 }, a, b); + assert!( + constraints + .zeros + .iter() + .all(|c| eval_expr(c, &values(&row, &[])) == G::ZERO) + ); + assert_eq!(message(&requests[0], &row, &[])[4], G::from_bool(a < b)); + // Every decomposition column participates in the compiled + // equations; wrong in-range advice cannot change the result. + let start = 3 + layout.selectors; + for limb in 0..6 { + let mut changed = row.clone(); + changed[start + limb] += G::ONE; + assert!( + constraints + .zeros + .iter() + .any(|c| eval_expr(c, &values(&changed, &[])) != G::ZERO) + ); + } + for input in 0..2 { + let mut changed = row.clone(); + changed[input] += G::from_u64(1 << 32); + assert!( + constraints + .zeros + .iter() + .any(|c| eval_expr(c, &values(&changed, &[])) != G::ZERO) + ); + } + } + } + let mut inactive = vec![-G::ONE; layout.width()]; + inactive[2..3 + layout.selectors].fill(G::ZERO); + assert!( + constraints + .zeros + .iter() + .all(|c| eval_expr(c, &values(&inactive, &[])) == G::ZERO) + ); + assert!(requests.iter().all(|request| eval_expr( + &request.multiplicity, + &values(&inactive, &[]) + ) == G::ZERO)); + } + } +} + +#[test] +fn u32_compare_proofs_and_decoded_keys_cover_boundaries_and_partitions() { + for grouped in [false, true] { + let (mut cp, fp) = test_parameters(); + cp.log_blowup = 2; + let system = AiurSystem::build(comparison_toplevel(grouped), cp, fp); + let encoded = crate::vk_codec::aiur_system_to_bytes(&system).unwrap(); + let (decoded, _, _) = crate::vk_codec::from_bytes(&encoded).unwrap(); + for member in 0..2 { + for (a, b) in + [(0, u32::MAX), (u32::MAX, 0), (65535, 65536), (u32::MAX, u32::MAX)] + { + let input = [G::from_u32(a), G::from_u32(b)]; + let (record, output) = system + .toplevel + .execute(member, input.to_vec(), &mut empty_io_buffer()) + .unwrap(); + assert_eq!(output, [G::from_bool(a < b)]); + let byte_circuit = system.toplevel.circuits.len() + 1; + let (table, _) = + Bytes2.witness_data(&record, &system.slot_arg_widths(byte_circuit)); + let mut expected = vec![G::ZERO; 65_536]; + for word in [a, a.wrapping_sub(b), b] { + expected[usize::from((word & 0xffff) as u16)] += G::ONE; + expected[usize::from((word >> 16) as u16)] += G::ONE; + } + for (row, count) in table.values.chunks_exact(table.width).zip(expected) + { + assert_eq!(row[Bytes2::U16_RANGE_CHECK_COLUMN], count); + assert!( + row[..Bytes2::U16_RANGE_CHECK_COLUMN].iter().all(|x| *x == G::ZERO) + ); + } + let (claim, proof) = + system.prove(member, &input, &mut empty_io_buffer()); + assert_eq!(claim.last(), Some(&G::from_bool(a < b))); + system.verify(&claim, &proof).unwrap(); + decoded.verify(&claim, &proof).unwrap(); + let mut false_claim = claim.clone(); + *false_claim.last_mut().unwrap() = G::from_bool(a >= b); + assert!(system.verify(&false_claim, &proof).is_err()); + } + for bad in [G::from_u64(1 << 32), -G::ONE] { + for input in [[bad, G::ZERO], [G::ZERO, bad]] { + assert!(matches!( + system.toplevel.execute( + member, + input.to_vec(), + &mut empty_io_buffer() + ), + Err(ExecError::U32OutOfRange(_)) + )); + } + } + } + } +} + +#[test] +fn u32_compare_supplied_out_of_range_limbs_fail_lookup_verification() { + // These witnesses satisfy every local polynomial, including the whole-word + // carry bit. Each missing u16 bound would admit an invalid input or a false + // comparison of valid inputs. Supply them directly to bypass execution. + let cases = [ + (1_u64 << 32, 1_u64, [0_i64, 65536, 65535, 65535, 1, 0], false), + (0, 1_u64 << 32, [0, 0, 0, 0, 0, 65536], true), + (1, 2, [1, 0, -1, 0, 2, 0], false), + (0, 0, [0, 0, 0, 65536, 0, 0], true), + // Field wraparound also satisfies the carry equation unless the + // input limbs are range-checked. This literal is Goldilocks p - 1. + (0xffff_ffff_0000_0000, 0, [-1, 0, 65535, 65535, 0, 0], true), + (0, 0xffff_ffff_0000_0000, [0, 0, 1, 0, -1, 0], false), + ]; + for grouped in [false, true] { + let (cp, fp) = test_parameters(); + let system = AiurSystem::build(comparison_toplevel(grouped), cp, fp); + let member = 1; + let selected = if grouped { 0 } else { member }; + let layout = system.toplevel.circuits[selected].layout; + let (constraints, requests) = system.toplevel.build_constraints(selected); + for (a, b, limbs, output) in cases { + let mut traces = Vec::new(); + for (index, shape) in system.circuit_shapes().iter().enumerate() { + let height = if shape.preprocessed_height == 0 { + 4 + } else { + shape.preprocessed_height + }; + let mut rows = vec![G::ZERO; height * shape.main_width]; + if index == selected { + rows[0] = G::from_u64(a); + rows[1] = G::from_u64(b); + rows[2 + if grouped { member } else { 0 }] = G::ONE; + rows[2 + layout.selectors] = G::ONE; + for (i, limb) in limbs.into_iter().enumerate() { + rows[3 + layout.selectors + i] = if limb < 0 { + -G::ONE + } else { + G::from_u64(u64::try_from(limb).unwrap()) + }; + } + let row = &rows[..shape.main_width]; + assert!( + constraints + .zeros + .iter() + .all(|c| eval_expr(c, &values(row, &[])) == G::ZERO) + ); + assert_eq!(message(&requests[0], row, &[])[4], G::from_bool(output)); + } else if index == system.toplevel.circuits.len() + 1 { + for limb in limbs { + if let Ok(value) = u16::try_from(limb) { + rows[usize::from(value) * shape.main_width + + Bytes2::U16_RANGE_CHECK_COLUMN] += G::ONE; + } + } + } + traces.push(RowMajorMatrix::new(rows, shape.main_width)); + } + let claim = [ + function_channel(), + G::from_usize(member), + G::from_u64(a), + G::from_u64(b), + G::from_bool(output), + ]; + let witness = SystemWitness::from_stage_1(traces, &system.system); + let proof = system.system.prove(&system.key, &claim, witness); + assert!(system.verify(&claim, &proof).is_err()); + } + } +} + +#[test] +fn u32_compare_advice_promotion_records_scalar_queries_once() { + for grouped in [false, true] { + let mut top = comparison_toplevel(grouped); + top.functions[0].body = Block { + ops: vec![ + Op::Call(1, vec![0, 1], 1, true), + Op::Call(1, vec![0, 1], 1, false), + Op::AssertEq(vec![2], vec![3], None), + ], + ctrl: Ctrl::Return(0, vec![3]), + }; + top.functions[0].layout.auxiliaries = 3; + top.functions[0].layout.lookups = 2; + if !grouped { + top.circuits[0].layout = top.functions[0].layout; + } + let (cp, fp) = test_parameters(); + let system = AiurSystem::build(top, cp, fp); + for input in [[G::from_u32(65535), G::from_u32(65536)], [G::ZERO, G::ZERO]] + { + let (record, output) = system + .toplevel + .execute(0, input.to_vec(), &mut empty_io_buffer()) + .unwrap(); + assert_eq!( + output, + [G::from_bool( + input[0].as_canonical_u64() < input[1].as_canonical_u64() + )] + ); + assert_eq!(record.function_queries[1].len(), 1); + let table_circuit = system.toplevel.circuits.len() + 1; + let (table, _) = + Bytes2.witness_data(&record, &system.slot_arg_widths(table_circuit)); + let count: G = table + .values + .chunks_exact(table.width) + .map(|row| row[Bytes2::U16_RANGE_CHECK_COLUMN]) + .sum(); + assert_eq!(count, G::from_u8(6)); + for row in table.values.chunks_exact(table.width) { + assert!( + row[..Bytes2::U16_RANGE_CHECK_COLUMN] + .iter() + .all(|value| *value == G::ZERO) + ); + } + let (claim, proof) = system.prove(0, &input, &mut empty_io_buffer()); + assert_eq!(claim.last(), output.first()); + system.verify(&claim, &proof).unwrap(); + } + } +} diff --git a/crates/aiur/src/trace.rs b/crates/aiur/src/trace.rs index 66e88cf92..b4813a1bf 100644 --- a/crates/aiur/src/trace.rs +++ b/crates/aiur/src/trace.rs @@ -20,11 +20,11 @@ use crate::{ function_channel, gadgets::{bytes1::Bytes1, bytes2::Bytes2}, memory::Memory, - querymap::QueryRef, - u8_add_channel, u8_and_channel, u8_bit_decomposition_channel, - u8_less_than_channel, u8_mul_channel, u8_or_channel, u8_range_check_channel, - u8_shift_left_channel, u8_shift_right_channel, u8_sub_channel, - u8_xor_channel, u8_xor_split4_channel, u8_xor_split7_channel, + querymap::QueryMap, + u8_add_channel, u8_bit_decomposition_channel, u8_mul_channel, + u8_range_check_channel, u8_shift_left_channel, u8_shift_right_channel, + u8_sub_channel, u8_xor_channel, u8_xor_split4_channel, u8_xor_split7_channel, + u16_range_check_channel, }; struct ColumnIndex { @@ -101,15 +101,25 @@ struct TraceContext<'a> { query_record: &'a QueryRecord, } -/// One row of a circuit trace: the member function it belongs to, the -/// member's selector offset within the circuit, its function index, and the -/// recorded query. -struct RowMeta<'a> { +/// Shared by all queried rows of one member of a circuit. +struct MemberMeta<'a> { function: &'a Function, sel_offset: usize, function_index: G, - inputs: &'a [G], - result: QueryRef<'a>, + queries: &'a QueryMap, +} + +/// Query slices and function metadata stay in their original storage. +/// Only these two indices are repeated per active row. +struct RowMeta { + member: usize, + query: usize, +} + +/// Function witness metadata, excluding the lookup row writers shared by +/// every circuit type. The estimator may conservatively include advice rows. +pub(crate) fn witness_metadata_bytes(members: usize, rows: usize) -> usize { + members * size_of::>() + rows * size_of::() } impl Toplevel { @@ -124,26 +134,32 @@ impl Toplevel { let layout = &circuit.layout; let width = layout.width(); // Concatenate the members' queried rows, in member order. - let mut rows_meta = Vec::new(); + let mut members_meta = Vec::with_capacity(circuit.members.len()); let mut sel_offset = 0; for &member in &circuit.members { let function = &self.functions[member]; - let function_index = G::from_usize(member); + members_meta.push(MemberMeta { + function, + sel_offset, + function_index: G::from_usize(member), + queries: &query_record.function_queries[member], + }); + sel_offset += function.layout.selectors; + } + // Count before allocating: no geometric growth or metadata for advice. + fn active_queries(queries: &QueryMap) -> impl Iterator + '_ { + (0..queries.len()).filter(|&i| !queries.mult_at(i).is_zero()) + } + let height_no_padding = members_meta + .iter() + .map(|member| active_queries(member.queries).count()) + .sum(); + let mut rows_meta = Vec::with_capacity(height_no_padding); + for (member, meta) in members_meta.iter().enumerate() { rows_meta.extend( - query_record.function_queries[member] - .iter() - .filter(|(_, res)| !res.multiplicity.is_zero()) - .map(|(inputs, result)| RowMeta { - function, - sel_offset, - function_index, - inputs, - result, - }), + active_queries(meta.queries).map(|query| RowMeta { member, query }), ); - sel_offset += function.layout.selectors; } - let height_no_padding = rows_meta.len(); // An unqueried circuit yields an EMPTY trace (not a padded height-1 one): // the prover deactivates it, so it is neither committed nor opened. let height = if height_no_padding == 0 { @@ -162,7 +178,10 @@ impl Toplevel { .zip(row_writers[..height_no_padding].par_iter_mut()) .enumerate() .for_each(|(i, (row, lookups))| { - let meta = &rows_meta[i]; + let row_meta = &rows_meta[i]; + let meta = &members_meta[row_meta.member]; + let (inputs, result) = + meta.queries.get_index(row_meta.query).expect("recorded query"); let index = &mut ColumnIndex { auxiliary: 0, // we skip the first lookup, which is reserved for return @@ -177,9 +196,9 @@ impl Toplevel { ); let context = TraceContext { function_index: meta.function_index, - inputs: meta.inputs, - multiplicity: meta.result.multiplicity, - output: meta.result.output, + inputs, + multiplicity: result.multiplicity, + output: result.output, query_record, }; meta.function.populate_row(index, slice, context, io_buffer); @@ -558,7 +577,11 @@ impl Op { let and = Bytes2::and(&i, &j); map.push((and, 1)); slice.push_auxiliary(index, and); - slice.push_lookup(index, G::ONE, &[u8_and_channel(), i, j, and]); + slice.push_lookup( + index, + G::ONE, + &[u8_xor_channel(), i, j, i + j - G::TWO * and], + ); }, Op::U8Or(i, j) => { let (i, _) = map[*i]; @@ -566,7 +589,11 @@ impl Op { let or = Bytes2::or(&i, &j); map.push((or, 1)); slice.push_auxiliary(index, or); - slice.push_lookup(index, G::ONE, &[u8_or_channel(), i, j, or]); + slice.push_lookup( + index, + G::ONE, + &[u8_xor_channel(), i, j, G::TWO * or - i - j], + ); }, Op::U8LessThan(i, j) => { let (i, _) = map[*i]; @@ -577,7 +604,7 @@ impl Op { slice.push_lookup( index, G::ONE, - &[u8_less_than_channel(), i, j, less_than], + &[u8_sub_channel(), i, j, i - j + G::from_u16(256) * less_than], ); }, Op::U8XorSplit7(i, j) => { @@ -611,37 +638,21 @@ impl Op { let (b, _) = map[*y_idx]; let a_u32 = u32::try_from(a.as_canonical_u64()).unwrap(); let b_u32 = u32::try_from(b.as_canonical_u64()).unwrap(); - let x_bytes: [u8; 4] = a_u32.to_le_bytes(); - let z_bytes: [u8; 4] = b_u32.to_le_bytes(); - // Witness: c = if a < b then b - a - 1 else 2^32 + b - a - 1 - let c_u32 = b_u32.wrapping_sub(a_u32).wrapping_sub(1); - let y_bytes: [u8; 4] = c_u32.to_le_bytes(); - - // Push 12 byte auxiliaries: x (a bytes), y (c bytes), z (b bytes) - for &byte in x_bytes.iter().chain(y_bytes.iter()).chain(z_bytes.iter()) - { - slice.push_auxiliary(index, G::from_u8(byte)); - } - - // Range-check byte pairs via Bytes2 lookups - let rc_channel = u8_range_check_channel(); - for (i, j) in [ - (x_bytes[0], x_bytes[1]), - (x_bytes[2], x_bytes[3]), - (y_bytes[0], y_bytes[1]), - (y_bytes[2], y_bytes[3]), - (z_bytes[0], z_bytes[1]), - (z_bytes[2], z_bytes[3]), - ] { - slice.push_lookup( - index, - G::ONE, - &[rc_channel, G::from_u8(i), G::from_u8(j)], - ); + let c_u32 = a_u32.wrapping_sub(b_u32); + // Six auxiliaries and scalar queries, ordered as a, c, b, low first. + // Execution already recorded these multiplicities. + for word in [a_u32, c_u32, b_u32] { + for shift in [0, 16] { + let limb = G::from_u16(((word >> shift) & 0xffff) as u16); + slice.push_auxiliary(index, limb); + slice.push_lookup( + index, + G::ONE, + &[u16_range_check_channel(), limb], + ); + } } - - let result = G::from_bool(a_u32 < b_u32); - map.push((result, 1)); + map.push((G::from_bool(a_u32 < b_u32), 1)); }, Op::U8RangeCheck(i, j) => { // No `map.push`: the `u8` outputs alias the inputs. Just require the diff --git a/crates/ixvm-codegen/src/aiur_ix_aggr.rs b/crates/ixvm-codegen/src/aiur_ix_aggr.rs index 0b534f731..0856bda4f 100644 --- a/crates/ixvm-codegen/src/aiur_ix_aggr.rs +++ b/crates/ixvm-codegen/src/aiur_ix_aggr.rs @@ -28,7 +28,7 @@ fn aiur_fn_0( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __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 & 0xffff) 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(&inp[..], &__ret[..], !unconstrained); return Ok(__ret); @@ -10189,7 +10189,7 @@ fn aiur_fn_105( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __v_9: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + 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 & 0xffff) 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_105] = { let __args: [G; IN_105] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__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, record, io_buffer, __cu)? } }; @@ -13455,7 +13455,7 @@ fn aiur_fn_143( 0u64 => { let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__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, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + 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 & 0xffff) 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_143] = [__v_4]; @@ -15157,7 +15157,7 @@ fn aiur_fn_159( let __v_127: G = __r_arr[1]; let __v_128: G = (__v_32 + __v_28); let __v_129: G = G::from_u64(33); - let __v_130: G = { let __a_val = __v_128.as_canonical_u64(); let __b_val = __v_129.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_130: G = { let __a_val = __v_128.as_canonical_u64(); let __b_val = __v_129.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; let __v_131: G = G::from_u64(1); if (__v_130 != __v_131) { return Err(ExecError::AssertEqMismatch { lhs: __v_130.as_canonical_u64(), rhs: __v_131.as_canonical_u64(), msg: None }); @@ -19349,7 +19349,7 @@ fn aiur_fn_199( let __v_476: G = __r_arr[1]; let __v_477: G = (__v_381 + __v_0); let __v_478: G = G::from_u64(33); - let __v_479: G = { let __a_val = __v_477.as_canonical_u64(); let __b_val = __v_478.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_479: G = { let __a_val = __v_477.as_canonical_u64(); let __b_val = __v_478.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; let __v_480: G = G::from_u64(1); if (__v_479 != __v_480) { return Err(ExecError::AssertEqMismatch { lhs: __v_479.as_canonical_u64(), rhs: __v_480.as_canonical_u64(), msg: None }); @@ -20642,7 +20642,7 @@ fn aiur_fn_213( return Ok(__ret); }, _ => { - let __v_218: G = { let __a_val = __v_207.as_canonical_u64(); let __b_val = __v_216.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_218: G = { let __a_val = __v_207.as_canonical_u64(); let __b_val = __v_216.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_218.as_canonical_u64() { 1u64 => { let __v_219: G = G::from_u64(0); @@ -20661,7 +20661,7 @@ fn aiur_fn_213( } }, _ => { - let __v_199: G = { let __a_val = __v_188.as_canonical_u64(); let __b_val = __v_197.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_199: G = { let __a_val = __v_188.as_canonical_u64(); let __b_val = __v_197.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_199.as_canonical_u64() { 1u64 => { let __v_200: G = G::from_u64(0); @@ -20680,7 +20680,7 @@ fn aiur_fn_213( } }, _ => { - let __v_180: G = { let __a_val = __v_169.as_canonical_u64(); let __b_val = __v_178.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_180: G = { let __a_val = __v_169.as_canonical_u64(); let __b_val = __v_178.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_180.as_canonical_u64() { 1u64 => { let __v_181: G = G::from_u64(0); @@ -20699,7 +20699,7 @@ fn aiur_fn_213( } }, _ => { - let __v_161: G = { let __a_val = __v_150.as_canonical_u64(); let __b_val = __v_159.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_161: G = { let __a_val = __v_150.as_canonical_u64(); let __b_val = __v_159.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_161.as_canonical_u64() { 1u64 => { let __v_162: G = G::from_u64(0); @@ -20718,7 +20718,7 @@ fn aiur_fn_213( } }, _ => { - let __v_142: G = { let __a_val = __v_131.as_canonical_u64(); let __b_val = __v_140.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_142: G = { let __a_val = __v_131.as_canonical_u64(); let __b_val = __v_140.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_142.as_canonical_u64() { 1u64 => { let __v_143: G = G::from_u64(0); @@ -20737,7 +20737,7 @@ fn aiur_fn_213( } }, _ => { - let __v_123: G = { let __a_val = __v_112.as_canonical_u64(); let __b_val = __v_121.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_123: G = { let __a_val = __v_112.as_canonical_u64(); let __b_val = __v_121.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_123.as_canonical_u64() { 1u64 => { let __v_124: G = G::from_u64(0); @@ -20756,7 +20756,7 @@ fn aiur_fn_213( } }, _ => { - let __v_104: G = { let __a_val = __v_93.as_canonical_u64(); let __b_val = __v_102.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_104: G = { let __a_val = __v_93.as_canonical_u64(); let __b_val = __v_102.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_104.as_canonical_u64() { 1u64 => { let __v_105: G = G::from_u64(0); @@ -20775,7 +20775,7 @@ fn aiur_fn_213( } }, _ => { - let __v_85: G = { let __a_val = __v_74.as_canonical_u64(); let __b_val = __v_83.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_85: G = { let __a_val = __v_74.as_canonical_u64(); let __b_val = __v_83.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_85.as_canonical_u64() { 1u64 => { let __v_86: G = G::from_u64(0); @@ -23466,7 +23466,7 @@ fn aiur_fn_238( let __v_529: G = __r_arr[1]; let __v_530: G = (__v_434 + __v_0); let __v_531: G = G::from_u64(33); - let __v_532: G = { let __a_val = __v_530.as_canonical_u64(); let __b_val = __v_531.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_532: G = { let __a_val = __v_530.as_canonical_u64(); let __b_val = __v_531.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; let __v_533: G = G::from_u64(1); if (__v_532 != __v_533) { return Err(ExecError::AssertEqMismatch { lhs: __v_532.as_canonical_u64(), rhs: __v_533.as_canonical_u64(), msg: None }); diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs index 2e22b613d..90691f62c 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm.rs @@ -28,7 +28,7 @@ fn aiur_fn_0( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __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 & 0xffff) 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(&inp[..], &__ret[..], !unconstrained); return Ok(__ret); @@ -15589,7 +15589,7 @@ fn aiur_fn_131( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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_131] = [__v_0, __v_1]; @@ -18985,7 +18985,7 @@ fn aiur_fn_192( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -19048,7 +19048,7 @@ fn aiur_fn_193( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -19732,7 +19732,7 @@ fn aiur_fn_205( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -19823,7 +19823,7 @@ fn aiur_fn_206( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -19868,7 +19868,7 @@ fn aiur_fn_206( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -19913,7 +19913,7 @@ fn aiur_fn_206( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -20103,7 +20103,7 @@ fn aiur_fn_208( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -21132,7 +21132,7 @@ fn aiur_fn_225( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -21260,7 +21260,7 @@ fn aiur_fn_225( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -21398,7 +21398,7 @@ fn aiur_fn_226( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -21489,7 +21489,7 @@ fn aiur_fn_227( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -21787,7 +21787,7 @@ fn aiur_fn_232( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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_232] = [__v_25, __v_15]; @@ -21846,7 +21846,7 @@ fn aiur_fn_232( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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_232] = [__v_32, __v_18]; @@ -22579,7 +22579,7 @@ fn aiur_fn_242( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -22589,7 +22589,7 @@ fn aiur_fn_242( }, _ => { 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -22600,7 +22600,7 @@ fn aiur_fn_242( }, _ => { 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -22656,7 +22656,7 @@ fn aiur_fn_243( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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_243] = [__v_0, __v_1]; @@ -22734,25 +22734,25 @@ fn aiur_fn_245( let __v_12: G = G::from_u64(0); let __v_13: G = if unconstrained { Bytes2::xor(&__v_5, &__v_12) } else { bytes2_xor_value(__v_5, __v_12, record) }; let __v_14: G = G::from_u64(64); - let __v_15: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_14.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_15: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_14.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; let __v_16: G = G::from_u64(1); if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("utf8 group 0 is not a 6-bit value".to_string()) }); } let __v_17: G = G::from_u64(64); - let __v_18: G = { let __a_val = __v_9.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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_18: G = { let __a_val = __v_9.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 & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; let __v_19: G = G::from_u64(1); if (__v_18 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("utf8 group 1 is not a 6-bit value".to_string()) }); } let __v_20: G = G::from_u64(64); - let __v_21: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_20.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_21: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_20.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; let __v_22: G = G::from_u64(1); if (__v_21 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("utf8 group 2 is not a 6-bit value".to_string()) }); } let __v_23: G = G::from_u64(64); - let __v_24: G = { let __a_val = __v_13.as_canonical_u64(); let __b_val = __v_23.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_24: G = { let __a_val = __v_13.as_canonical_u64(); let __b_val = __v_23.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; 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("utf8 group 3 is not a 6-bit value".to_string()) }); @@ -22770,7 +22770,7 @@ fn aiur_fn_245( return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("utf8 groups do not recompose to the codepoint".to_string()) }); } let __v_35: G = G::from_u64(128); - let __v_36: G = { let __a_val = __v_0.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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_36: G = { let __a_val = __v_0.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 & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_36.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(0); @@ -22781,7 +22781,7 @@ fn aiur_fn_245( }, _ => { let __v_37: G = G::from_u64(2048); - let __v_38: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_37.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_38: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_37.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_38.as_canonical_u64() { 1u64 => { let __v_39: G = G::from_u64(128); @@ -22798,7 +22798,7 @@ fn aiur_fn_245( }, _ => { let __v_39: G = G::from_u64(65536); - let __v_40: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_39.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_40: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_39.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_40.as_canonical_u64() { 1u64 => { let __v_41: G = G::from_u64(128); @@ -23927,7 +23927,7 @@ fn aiur_fn_258( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -24000,7 +24000,7 @@ fn aiur_fn_258( }, _ => { 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -25058,7 +25058,7 @@ fn aiur_fn_267( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -25176,7 +25176,7 @@ fn aiur_fn_268( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -25229,7 +25229,7 @@ fn aiur_fn_268( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -25308,7 +25308,7 @@ fn aiur_fn_269( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -28759,7 +28759,7 @@ fn aiur_fn_304( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -28768,7 +28768,7 @@ fn aiur_fn_304( return Ok(__ret); }, 0u64 => { - let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + 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 & 0xffff) 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); @@ -28841,7 +28841,7 @@ fn aiur_fn_305( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -28850,7 +28850,7 @@ fn aiur_fn_305( return Ok(__ret); }, 0u64 => { - let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + 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 & 0xffff) 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_305] = { let __args: [G; IN_305] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[305].get_index_of(&__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, record, io_buffer, __cu)? } }; @@ -28988,7 +28988,7 @@ fn aiur_fn_307( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -28999,7 +28999,7 @@ fn aiur_fn_307( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -29069,7 +29069,7 @@ fn aiur_fn_308( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -29080,7 +29080,7 @@ fn aiur_fn_308( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -29092,7 +29092,7 @@ fn aiur_fn_308( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -29268,7 +29268,7 @@ fn aiur_fn_310( _ => { let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__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, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + 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 & 0xffff) 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_310] = [__v_5]; @@ -29338,7 +29338,7 @@ fn aiur_fn_311( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -29350,7 +29350,7 @@ fn aiur_fn_311( return Ok(__ret); }, 0u64 => { - let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + 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 & 0xffff) 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_311] = { let __args: [G; IN_311] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__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, record, io_buffer, __cu)? } }; @@ -29360,7 +29360,7 @@ fn aiur_fn_311( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -29505,7 +29505,7 @@ fn aiur_fn_313( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -29944,7 +29944,7 @@ fn aiur_fn_318( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; break '__mc_1 [__v_13]; }, _ => { @@ -29967,7 +29967,7 @@ fn aiur_fn_318( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; break '__mc_2 [__v_20]; }, _ => { @@ -30278,7 +30278,7 @@ fn aiur_fn_321( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -30356,7 +30356,7 @@ fn aiur_fn_322( _ => { 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -30493,7 +30493,7 @@ fn aiur_fn_324( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -30829,7 +30829,7 @@ fn aiur_fn_330( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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_330] = [__v_1]; @@ -31182,7 +31182,7 @@ fn aiur_fn_334( let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __v_9: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_9: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_334] = [__v_1]; @@ -32110,7 +32110,7 @@ fn aiur_fn_348( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __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 & 0xffff) 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_348] = [__v_1]; @@ -32170,7 +32170,7 @@ fn aiur_fn_350( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __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 & 0xffff) 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_350] = [__v_0]; @@ -32209,7 +32209,7 @@ fn aiur_fn_351( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -32218,7 +32218,7 @@ fn aiur_fn_351( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; let __ret: [G; OUT_351] = [__v_8]; record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained); return Ok(__ret); @@ -32439,7 +32439,7 @@ fn aiur_fn_355( let __v_1: G = inp[1]; let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[356].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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_355] = [__v_2]; @@ -32520,7 +32520,7 @@ fn aiur_fn_357( _ => { let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[356].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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_357] = [__v_2]; @@ -32571,7 +32571,7 @@ fn aiur_fn_358( _ => { let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_358] = [__v_0]; @@ -33018,7 +33018,7 @@ fn aiur_fn_365( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -33141,7 +33141,7 @@ fn aiur_fn_368( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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_368] = [__v_0]; @@ -34565,7 +34565,7 @@ fn aiur_fn_390( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -34846,7 +34846,7 @@ fn aiur_fn_393( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -34899,7 +34899,7 @@ fn aiur_fn_393( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -35465,7 +35465,7 @@ fn aiur_fn_398( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -35533,7 +35533,7 @@ fn aiur_fn_399( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -35884,7 +35884,7 @@ fn aiur_fn_402( 1u64 => { let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -35965,7 +35965,7 @@ fn aiur_fn_403( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -36512,7 +36512,7 @@ fn aiur_fn_409( let __v_12: G = (__v_2 + __v_11); let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -39749,7 +39749,7 @@ fn aiur_fn_445( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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_446] = { let __args: [G; IN_446] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[446].get_index_of(&__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, record, io_buffer, __cu)? } }; @@ -42759,7 +42759,7 @@ fn aiur_fn_479( let __v_34: G = __r_arr[0]; let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__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; let __hit = record.function_queries[478].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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_480] = { let __args: [G; IN_480] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[480].get_index_of(&__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, record, io_buffer, __cu)? } }; @@ -42771,7 +42771,7 @@ fn aiur_fn_479( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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_481] = { let __args: [G; IN_481] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[481].get_index_of(&__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, record, io_buffer, __cu)? } }; @@ -46269,7 +46269,7 @@ fn aiur_fn_534( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -46431,7 +46431,7 @@ fn aiur_fn_536( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -46808,7 +46808,7 @@ fn aiur_fn_540( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -46989,7 +46989,7 @@ fn aiur_fn_541( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_48]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); - let __v_51: G = { let __a_val = __v_49.as_canonical_u64(); let __b_val = __v_50.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_51: G = { let __a_val = __v_49.as_canonical_u64(); let __b_val = __v_50.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_51.as_canonical_u64() { 1u64 => { let __v_52: G = G::from_u64(0); @@ -47081,7 +47081,7 @@ fn aiur_fn_542( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); - let __v_19: G = { let __a_val = __v_17.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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_19: G = { let __a_val = __v_17.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 & 0xffff) 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); @@ -47144,7 +47144,7 @@ fn aiur_fn_543( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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); @@ -49557,7 +49557,7 @@ fn aiur_fn_575( let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_12, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__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, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_17: 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 & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_17.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_575] = [__v_16, __v_10]; @@ -50513,7 +50513,7 @@ fn aiur_fn_590( let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_56]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_u64(2); - let __v_59: G = { let __a_val = __v_57.as_canonical_u64(); let __b_val = __v_58.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_59: G = { let __a_val = __v_57.as_canonical_u64(); let __b_val = __v_58.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_59.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_590] = []; @@ -50840,7 +50840,7 @@ fn aiur_fn_594( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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()) }); @@ -50912,7 +50912,7 @@ fn aiur_fn_596( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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()) }); @@ -55937,7 +55937,7 @@ fn aiur_fn_659( _ => { let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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_782] = { let __args: [G; IN_782] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__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, record, io_buffer, __cu)? } }; @@ -57324,7 +57324,7 @@ fn aiur_fn_681( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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()) }); @@ -58306,7 +58306,7 @@ fn aiur_fn_692( _ => { let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__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, record, io_buffer, __cu)? } }; 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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_782] = { let __args: [G; IN_782] = [__v_4, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__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, record, io_buffer, __cu)? } }; @@ -65500,7 +65500,7 @@ fn aiur_fn_777( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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_777] = { let __args: [G; IN_777] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__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, record, io_buffer, __cu)? } }; @@ -66626,7 +66626,7 @@ fn aiur_fn_796( 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 __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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 & 0xffff) 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_796] = { let __args: [G; IN_796] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[796].get_index_of(&__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, record, io_buffer, __cu)? } }; diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs index 8ca26c402..2a12d0454 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs @@ -28,7 +28,7 @@ fn aiur_fn_0( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __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 & 0xffff) 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(&inp[..], &__ret[..], !unconstrained); return Ok(__ret); @@ -10189,7 +10189,7 @@ fn aiur_fn_105( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __v_9: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + 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 & 0xffff) 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_105] = { let __args: [G; IN_105] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__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, record, io_buffer, __cu)? } }; @@ -13455,7 +13455,7 @@ fn aiur_fn_143( 0u64 => { let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__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, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + 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 & 0xffff) 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_143] = [__v_4]; @@ -15157,7 +15157,7 @@ fn aiur_fn_159( let __v_127: G = __r_arr[1]; let __v_128: G = (__v_32 + __v_28); let __v_129: G = G::from_u64(33); - let __v_130: G = { let __a_val = __v_128.as_canonical_u64(); let __b_val = __v_129.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_130: G = { let __a_val = __v_128.as_canonical_u64(); let __b_val = __v_129.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; let __v_131: G = G::from_u64(1); if (__v_130 != __v_131) { return Err(ExecError::AssertEqMismatch { lhs: __v_130.as_canonical_u64(), rhs: __v_131.as_canonical_u64(), msg: None }); @@ -19349,7 +19349,7 @@ fn aiur_fn_199( let __v_476: G = __r_arr[1]; let __v_477: G = (__v_381 + __v_0); let __v_478: G = G::from_u64(33); - let __v_479: G = { let __a_val = __v_477.as_canonical_u64(); let __b_val = __v_478.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_479: G = { let __a_val = __v_477.as_canonical_u64(); let __b_val = __v_478.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; let __v_480: G = G::from_u64(1); if (__v_479 != __v_480) { return Err(ExecError::AssertEqMismatch { lhs: __v_479.as_canonical_u64(), rhs: __v_480.as_canonical_u64(), msg: None }); @@ -20642,7 +20642,7 @@ fn aiur_fn_213( return Ok(__ret); }, _ => { - let __v_218: G = { let __a_val = __v_207.as_canonical_u64(); let __b_val = __v_216.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_218: G = { let __a_val = __v_207.as_canonical_u64(); let __b_val = __v_216.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_218.as_canonical_u64() { 1u64 => { let __v_219: G = G::from_u64(0); @@ -20661,7 +20661,7 @@ fn aiur_fn_213( } }, _ => { - let __v_199: G = { let __a_val = __v_188.as_canonical_u64(); let __b_val = __v_197.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_199: G = { let __a_val = __v_188.as_canonical_u64(); let __b_val = __v_197.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_199.as_canonical_u64() { 1u64 => { let __v_200: G = G::from_u64(0); @@ -20680,7 +20680,7 @@ fn aiur_fn_213( } }, _ => { - let __v_180: G = { let __a_val = __v_169.as_canonical_u64(); let __b_val = __v_178.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_180: G = { let __a_val = __v_169.as_canonical_u64(); let __b_val = __v_178.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_180.as_canonical_u64() { 1u64 => { let __v_181: G = G::from_u64(0); @@ -20699,7 +20699,7 @@ fn aiur_fn_213( } }, _ => { - let __v_161: G = { let __a_val = __v_150.as_canonical_u64(); let __b_val = __v_159.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_161: G = { let __a_val = __v_150.as_canonical_u64(); let __b_val = __v_159.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_161.as_canonical_u64() { 1u64 => { let __v_162: G = G::from_u64(0); @@ -20718,7 +20718,7 @@ fn aiur_fn_213( } }, _ => { - let __v_142: G = { let __a_val = __v_131.as_canonical_u64(); let __b_val = __v_140.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_142: G = { let __a_val = __v_131.as_canonical_u64(); let __b_val = __v_140.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_142.as_canonical_u64() { 1u64 => { let __v_143: G = G::from_u64(0); @@ -20737,7 +20737,7 @@ fn aiur_fn_213( } }, _ => { - let __v_123: G = { let __a_val = __v_112.as_canonical_u64(); let __b_val = __v_121.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_123: G = { let __a_val = __v_112.as_canonical_u64(); let __b_val = __v_121.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_123.as_canonical_u64() { 1u64 => { let __v_124: G = G::from_u64(0); @@ -20756,7 +20756,7 @@ fn aiur_fn_213( } }, _ => { - let __v_104: G = { let __a_val = __v_93.as_canonical_u64(); let __b_val = __v_102.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_104: G = { let __a_val = __v_93.as_canonical_u64(); let __b_val = __v_102.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_104.as_canonical_u64() { 1u64 => { let __v_105: G = G::from_u64(0); @@ -20775,7 +20775,7 @@ fn aiur_fn_213( } }, _ => { - let __v_85: G = { let __a_val = __v_74.as_canonical_u64(); let __b_val = __v_83.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_85: G = { let __a_val = __v_74.as_canonical_u64(); let __b_val = __v_83.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; match __v_85.as_canonical_u64() { 1u64 => { let __v_86: G = G::from_u64(0); @@ -23123,7 +23123,7 @@ fn aiur_fn_237( let __v_529: G = __r_arr[1]; let __v_530: G = (__v_434 + __v_0); let __v_531: G = G::from_u64(33); - let __v_532: G = { let __a_val = __v_530.as_canonical_u64(); let __b_val = __v_531.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_532: G = { let __a_val = __v_530.as_canonical_u64(); let __b_val = __v_531.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; let __v_533: G = G::from_u64(1); if (__v_532 != __v_533) { return Err(ExecError::AssertEqMismatch { lhs: __v_532.as_canonical_u64(), rhs: __v_533.as_canonical_u64(), msg: None }); @@ -26438,7 +26438,7 @@ fn aiur_fn_242( let __v_955: G = __r_arr[1]; let __v_956: G = (__v_860 + __v_232); let __v_957: G = G::from_u64(33); - let __v_958: G = { let __a_val = __v_956.as_canonical_u64(); let __b_val = __v_957.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_958: G = { let __a_val = __v_956.as_canonical_u64(); let __b_val = __v_957.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __c_u32 = __a_u32.wrapping_sub(__b_u32); for __word in [__a_u32, __c_u32, __b_u32] { record.bytes2_queries.bump_u16_range_check((__word & 0xffff) as u16); record.bytes2_queries.bump_u16_range_check((__word >> 16) as u16); } } __result }; let __v_959: G = G::from_u64(1); if (__v_958 != __v_959) { return Err(ExecError::AssertEqMismatch { lhs: __v_958.as_canonical_u64(), rhs: __v_959.as_canonical_u64(), msg: None });