From e2d7daf8e9dad5712f717c49caecd227f8162d25 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Wed, 16 Sep 2026 02:29:22 +0000 Subject: [PATCH 1/7] perf(aiur): cache validated function claim shapes Summarize constrained return arities once during system construction and reuse them for call validation and public claim checks. Preserve existing acceptance semantics, including empty and inconsistent return trees. Extract claim caching from a8ee603b in PR #631 without callee-rank changes. Differential tests compare cached arities with the recursive predicate on nested branches and continuations. All 36 Aiur tests pass. Co-authored-by: John C. Burnham --- crates/aiur/src/lookup_shapes.rs | 145 ++++++++++++++---- crates/aiur/src/synthesis.rs | 8 +- .../aiur/src/synthesis/tests/lookup_shapes.rs | 84 +++++++++- 3 files changed, 205 insertions(+), 32 deletions(-) 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..37abfdc9a 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -21,6 +21,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}, }; @@ -76,6 +77,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 @@ -136,7 +138,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(); @@ -211,6 +214,7 @@ impl AiurSystem { system, key, toplevel, + claim_shapes, commitment_parameters, fri_parameters, slot_widths, @@ -578,7 +582,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( 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 { From f1534a874c69284ab7526b92ad4257f2a9f91961 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Wed, 16 Sep 2026 02:30:37 +0000 Subject: [PATCH 2/7] perf(aiur): tune lookup groups from compiled degree costs Retune accumulator grouping using actual expression degrees and the PCS quotient budget. Require no greater modeled FFT work at every integer row height, including one-row traces, and synchronize all circuit metadata before exposing the system or its transcript. Port c7a5a979 from PR #631 with rank-free fixtures. Cover degree budgets, verifying-key roundtrips, false claims, and mixed quotient degrees in the existing recursive-verifier suite. Preserve the corrected lookup gates. Co-authored-by: John C. Burnham --- Ix/Aiur/Stages/Bytecode.lean | 10 +- Tests/MultiStark.lean | 34 +++- crates/aiur/src/lib.rs | 1 + crates/aiur/src/lookup_groups.rs | 184 ++++++++++++++++++ crates/aiur/src/synthesis.rs | 23 ++- .../aiur/src/synthesis/tests/lookup_groups.rs | 140 +++++++++++++ 6 files changed, 375 insertions(+), 17 deletions(-) create mode 100644 crates/aiur/src/lookup_groups.rs create mode 100644 crates/aiur/src/synthesis/tests/lookup_groups.rs 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/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/lib.rs b/crates/aiur/src/lib.rs index 470d08b18..81442a2d5 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; 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/synthesis.rs b/crates/aiur/src/synthesis.rs index 37abfdc9a..af1405fc9 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, + 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, }; @@ -167,9 +169,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 @@ -209,7 +211,15 @@ 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, @@ -629,6 +639,7 @@ mod tests { mod branchless; mod byte_shapes; mod lookup_budget; + mod lookup_groups; mod lookup_shapes; mod mmcs; 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:?}"); + } + } + } +} From c00a791fea0828230229930041508e327d4a90c1 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Wed, 16 Sep 2026 02:32:28 +0000 Subject: [PATCH 3/7] perf(aiur): compact witness metadata and correct memory estimates Store member metadata once and two indices per active row, allocating the row index vector exactly once. Account for grouped member rows, actual extension-field storage, lookup writers and compact function metadata in prover-memory and shard estimates. Extract the host-side changes from 470eaea2 in PR #631. Omit its IxVM byte hint rewrite and all completion/rank machinery. Test reordered grouped members, advice-only rows, fixed tables and split estimates, plus an opt-in million-row witness construction measurement. Co-authored-by: John C. Burnham --- crates/aiur/src/synthesis.rs | 56 ++++--- .../aiur/src/synthesis/tests/host_timings.rs | 55 +++++++ crates/aiur/src/synthesis/tests/peak.rs | 137 ++++++++++++++++++ crates/aiur/src/trace.rs | 69 +++++---- 4 files changed, 275 insertions(+), 42 deletions(-) create mode 100644 crates/aiur/src/synthesis/tests/host_timings.rs create mode 100644 crates/aiur/src/synthesis/tests/peak.rs diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index af1405fc9..987afb5b5 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -1,7 +1,7 @@ use multi_stark::{ config::StarkGenericConfig, expr::Expr, - lookup::Lookup, + lookup::{Lookup, LookupRowMut}, p3_field::{BasedVectorSpace, PrimeCharacteristicRing}, p3_matrix::dense::RowMajorMatrix, prover::Proof, @@ -48,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; @@ -113,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)) }, @@ -275,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: /// @@ -298,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), ) } @@ -335,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; @@ -389,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; @@ -638,10 +658,12 @@ mod tests { mod acceptance; mod branchless; mod byte_shapes; + mod host_timings; mod lookup_budget; mod lookup_groups; mod lookup_shapes; mod mmcs; + mod peak; use super::*; use crate::{ 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/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/trace.rs b/crates/aiur/src/trace.rs index 66e88cf92..9bddfe299 100644 --- a/crates/aiur/src/trace.rs +++ b/crates/aiur/src/trace.rs @@ -20,7 +20,7 @@ use crate::{ function_channel, gadgets::{bytes1::Bytes1, bytes2::Bytes2}, memory::Memory, - querymap::QueryRef, + querymap::QueryMap, 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, @@ -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); From 1ea7a683046b26b002b97ccb79693304bb78ac07 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Wed, 16 Sep 2026 02:42:22 +0000 Subject: [PATCH 4/7] perf(aiur): consolidate byte lookup tables Express byte AND/OR through affine XOR messages and byte comparison through subtraction. Merge their multiplicities into the existing tables, removing three fixed-table columns and lookup channels while preserving operation outputs and function trace layouts. Keep old channel IDs reserved. Extract 9c8a6545 from PR #631 without rank-related witness/test changes. Exhaustively check all byte pairs in singleton and grouped circuits, reject forged outputs and nonbyte inputs, and roundtrip proofs and verifying keys. All 56 active Aiur tests and strict Clippy pass. Co-authored-by: John C. Burnham --- crates/aiur/src/constraints.rs | 64 ++-- crates/aiur/src/gadgets/bytes2.rs | 204 +++-------- crates/aiur/src/lib.rs | 3 + crates/aiur/src/synthesis.rs | 5 +- .../src/synthesis/tests/byte_consolidation.rs | 316 ++++++++++++++++++ crates/aiur/src/trace.rs | 21 +- 6 files changed, 426 insertions(+), 187 deletions(-) create mode 100644 crates/aiur/src/synthesis/tests/byte_consolidation.rs diff --git a/crates/aiur/src/constraints.rs b/crates/aiur/src/constraints.rs index b97a91a82..fdcad9959 100644 --- a/crates/aiur/src/constraints.rs +++ b/crates/aiur/src/constraints.rs @@ -13,10 +13,9 @@ 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, }; type Expr = multi_stark::expr::Expr; @@ -661,30 +660,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, diff --git a/crates/aiur/src/gadgets/bytes2.rs b/crates/aiur/src/gadgets/bytes2.rs index e013a6a34..283ca6e58 100644 --- a/crates/aiur/src/gadgets/bytes2.rs +++ b/crates/aiur/src/gadgets/bytes2.rs @@ -6,23 +6,20 @@ 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, }; /// 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; +const TRACE_WIDTH: usize = 7; /// Number of columns in the preprocessed trace: /// - first raw byte value @@ -32,16 +29,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 +93,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,9 +165,6 @@ 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()); @@ -187,13 +174,10 @@ impl AiurGadget for Bytes2 { 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); // Preprocessed columns let i = Expr::preprocessed(0); @@ -201,15 +185,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 +208,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], @@ -271,9 +237,6 @@ impl AiurGadget for Bytes2 { pull_xor, pull_add, pull_sub, - pull_and, - pull_or, - pull_less_than, pull_range_check, pull_mul, pull_xor_split7, @@ -287,101 +250,39 @@ 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] = *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]); + } drop(row_writers); (RowMajorMatrix::new(rows, TRACE_WIDTH), builder.finish()) } @@ -409,31 +310,31 @@ 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) } 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 +346,9 @@ impl Bytes2Queries { } impl Bytes2 { + /// Shared row and lookup-slot index of the byte-pair range channel. + pub(crate) const RANGE_CHECK_COLUMN: usize = 3; + #[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 81442a2d5..eb83d4fdb 100644 --- a/crates/aiur/src/lib.rs +++ b/crates/aiur/src/lib.rs @@ -60,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) diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 987afb5b5..e81fb51e1 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -201,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: 7 → 4 at height 65536). push_circuit( Bytes1.main_width(), Bytes1.preprocessed(), @@ -657,6 +657,7 @@ impl AiurSystem { mod tests { mod acceptance; mod branchless; + mod byte_consolidation; mod byte_shapes; mod host_timings; mod lookup_budget; @@ -1055,7 +1056,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..32b702823 --- /dev/null +++ b/crates/aiur/src/synthesis/tests/byte_consolidation.rs @@ -0,0 +1,316 @@ +// 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; 7]; + assert_eq!(table.width, 11); + assert_eq!(pulls.len(), 7); + + 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] + ); + } +} + +#[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 + ), + (7, 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] + ); + let (claim, proof) = + system.prove_from_execution(0, &input, &io, record, &output); + system.verify(&claim, &proof).unwrap(); + } +} diff --git a/crates/aiur/src/trace.rs b/crates/aiur/src/trace.rs index 9bddfe299..c622e075e 100644 --- a/crates/aiur/src/trace.rs +++ b/crates/aiur/src/trace.rs @@ -21,10 +21,9 @@ use crate::{ gadgets::{bytes1::Bytes1, bytes2::Bytes2}, memory::Memory, querymap::QueryMap, - 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, + 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, }; struct ColumnIndex { @@ -577,7 +576,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]; @@ -585,7 +588,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]; @@ -596,7 +603,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) => { From f29f77ebe1eb2326f20d6d2b7dae6a048406413f Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Wed, 16 Sep 2026 02:49:31 +0000 Subject: [PATCH 5/7] perf(aiur): use u16 limbs for u32 comparisons Replace twelve byte auxiliaries with six u16 limbs while preserving six range lookups, both input bounds, strict comparison and boolean carries. Add a distinct scalar u16 range channel to the shared byte table, and update compiler layouts, execution, witnesses and generated executors. Port 09e95317 from PR #631 plus only the generic range-table support it needs from e1d74d12. No call-rank encoding or cycle defense is introduced. Tests exhaust the scalar table, cover grouped and singleton boundaries, reject supplied invalid limbs and verify constrained advice promotion. Co-authored-by: John C. Burnham --- Ix/Aiur/Compiler/Layout.lean | 2 +- Ix/Aiur/Stages/Codegen.lean | 19 +- crates/aiur/src/constraints.rs | 100 ++--- crates/aiur/src/execute.rs | 16 +- crates/aiur/src/gadgets/bytes2.rs | 38 +- crates/aiur/src/lib.rs | 6 + crates/aiur/src/synthesis.rs | 3 +- .../src/synthesis/tests/byte_consolidation.rs | 19 +- .../aiur/src/synthesis/tests/u32_compare.rs | 373 ++++++++++++++++++ crates/aiur/src/trace.rs | 43 +- crates/ixvm-codegen/src/aiur_ix_aggr.rs | 28 +- crates/ixvm-codegen/src/aiur_ixvm.rs | 176 ++++----- crates/ixvm-codegen/src/aiur_multi_stark.rs | 30 +- 13 files changed, 605 insertions(+), 248 deletions(-) create mode 100644 crates/aiur/src/synthesis/tests/u32_compare.rs 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/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean index 4847e37b4..53c481bfc 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!" 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/crates/aiur/src/constraints.rs b/crates/aiur/src/constraints.rs index fdcad9959..8054d5328 100644 --- a/crates/aiur/src/constraints.rs +++ b/crates/aiur/src/constraints.rs @@ -16,6 +16,7 @@ use crate::{ 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; @@ -36,6 +37,8 @@ fn konst(value: G) -> Expr { /// `256⁻¹` in the Goldilocks field. The field inversion is expensive, so it is /// computed once and reused by the byte carry-chain constraints. static INV_256: LazyLock = LazyLock::new(|| G::from_u64(256).inverse()); +/// `65536⁻¹` for the two-limb u32 comparison carry chain. +static INV_65536: LazyLock = LazyLock::new(|| G::from_u64(65536).inverse()); /// Constant expression for `(2^32)⁻¹`, built once from its Goldilocks /// value and cloned into every virtual u32 carry. static INV_2_POW_32_EXPR: LazyLock = @@ -120,6 +123,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, @@ -724,78 +737,35 @@ 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 boolean carry chain establishes the integer relation + // a + c + 1 = b + carry * 2^32. + // Since 0 <= c < 2^32, a < b iff the final carry is zero. The +1 + // makes equality return false. All sums are far below Goldilocks 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 x: [Expr; 2] = array::from_fn(|_| state.next_auxiliary()); + let y: [Expr; 2] = array::from_fn(|_| state.next_auxiliary()); + let z: [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() * (a - recompose(&x))); + state.constraints.zeros.push(sel.clone() * (b - recompose(&z))); + + let mut carry = konst(G::ONE); + for k in 0..2 { + carry = (x[k].clone() + y[k].clone() + carry - z[k].clone()) + * konst(*INV_65536); state.constraints.zeros.push( - sel.clone() * (carry.clone() * (carry.clone() - konst(G::ONE))), + sel.clone() * carry.clone() * (carry.clone() - konst(G::ONE)), ); } - - // 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(); + for limb in x.into_iter().chain(y).chain(z) { + state.range_u16(sel, limb); } - - // Output: 1 - carry - let output = konst(G::ONE) - carry; - state.map.push((output, 1)); + state.map.push((konst(G::ONE) - 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..c8dd79889 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]), - ] { + 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 283ca6e58..2d7c0fc54 100644 --- a/crates/aiur/src/gadgets/bytes2.rs +++ b/crates/aiur/src/gadgets/bytes2.rs @@ -8,7 +8,7 @@ use multi_stark::{ use crate::{ G, execute::QueryRecord, gadgets::AiurGadget, u8_add_channel, u8_mul_channel, u8_range_check_channel, u8_sub_channel, u8_xor_channel, - u8_xor_split4_channel, u8_xor_split7_channel, + u8_xor_split4_channel, u8_xor_split7_channel, u16_range_check_channel, }; /// Number of columns in the trace with multiplicities for @@ -19,7 +19,8 @@ use crate::{ /// - mul /// - xor_split7 /// - xor_split4 -const TRACE_WIDTH: usize = 7; +/// - scalar u16 range_check +const TRACE_WIDTH: usize = 8; /// Number of columns in the preprocessed trace: /// - first raw byte value @@ -169,6 +170,7 @@ impl AiurGadget for Bytes2 { 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); @@ -178,6 +180,7 @@ impl AiurGadget for Bytes2 { 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); @@ -230,7 +233,20 @@ 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![ @@ -241,6 +257,7 @@ impl AiurGadget for Bytes2 { pull_mul, pull_xor_split7, pull_xor_split4, + pull_u16_range, ] } @@ -260,7 +277,8 @@ impl AiurGadget for Bytes2 { .zip(&record.bytes2_queries.0) .zip(row_writers.iter_mut()) { - let [xor, add, sub, range_check, mul, xor_split7, xor_split4] = *counts; + 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); @@ -282,6 +300,11 @@ impl AiurGadget for Bytes2 { 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()) @@ -325,6 +348,11 @@ impl Bytes2Queries { self.bump_multiplicity_for(i, j, Bytes2::RANGE_CHECK_COLUMN) } + /// Record a scalar u16 query on its distinct range channel. + pub fn bump_u16_range_check(&mut self, limb: u16) { + self.0[usize::from(limb)][Bytes2::U16_RANGE_CHECK_COLUMN] += G::ONE; + } + pub(crate) fn bump_mul(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 4) } @@ -348,6 +376,8 @@ 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 { diff --git a/crates/aiur/src/lib.rs b/crates/aiur/src/lib.rs index eb83d4fdb..16014f4a2 100644 --- a/crates/aiur/src/lib.rs +++ b/crates/aiur/src/lib.rs @@ -97,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/synthesis.rs b/crates/aiur/src/synthesis.rs index e81fb51e1..9607e7b8d 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -201,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: 7 → 4 at height 65536). + // stage-2 accumulators (Bytes2: 8 → 4 at height 65536). push_circuit( Bytes1.main_width(), Bytes1.preprocessed(), @@ -665,6 +665,7 @@ mod tests { mod lookup_shapes; mod mmcs; mod peak; + mod u32_compare; use super::*; use crate::{ diff --git a/crates/aiur/src/synthesis/tests/byte_consolidation.rs b/crates/aiur/src/synthesis/tests/byte_consolidation.rs index 32b702823..3ab831dd9 100644 --- a/crates/aiur/src/synthesis/tests/byte_consolidation.rs +++ b/crates/aiur/src/synthesis/tests/byte_consolidation.rs @@ -61,9 +61,9 @@ fn message(lookup: &Lookup>, row: &[G], preprocessed: &[G]) -> Vec { fn every_byte_pair_matches_the_consolidated_compiled_lookup() { let table = Bytes2.preprocessed().unwrap(); let pulls = Bytes2.lookups(); - let table_row = [G::ZERO; 7]; + let table_row = [G::ZERO; 8]; assert_eq!(table.width, 11); - assert_eq!(pulls.len(), 7); + assert_eq!(pulls.len(), 8); for grouped in [false, true] { let top = byte_toplevel(grouped); @@ -156,7 +156,7 @@ fn interpreter_and_generated_helpers_share_table_multiplicities() { 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::TWO, G::ZERO, G::ONE, G::ZERO, G::ZERO, G::ZERO, G::ZERO, G::ZERO] ); } } @@ -176,7 +176,7 @@ fn consolidated_byte_proofs_verify_in_both_partitions_and_key_codec() { shape.preprocessed_width, shape.preprocessed_height ), - (7, 8, 2, 11, 65_536) + (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(); @@ -307,7 +307,16 @@ fn original_and_consolidated_operations_share_multiplicities_in_one_proof() { [(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::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); 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..9a5af2b4a --- /dev/null +++ b/crates/aiur/src/synthesis/tests/u32_compare.rs @@ -0,0 +1,373 @@ +// 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 = b.wrapping_sub(a).wrapping_sub(1); + 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, b.wrapping_sub(a).wrapping_sub(1), 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 both carry + // bits. 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, 0, 0, 1, 0], false), + (0, 1_u64 << 32, [0, 0, 65535, 65535, 0, 65536], true), + (1, 2, [1, 0, 0, 65536, 2, 0], false), + (0, 0, [0, 0, 65535, -1, 0, 0], true), + ]; + 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 c622e075e..6ff17360e 100644 --- a/crates/aiur/src/trace.rs +++ b/crates/aiur/src/trace.rs @@ -24,6 +24,7 @@ use crate::{ 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 { @@ -637,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)); + // 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], + ); + } } - - // 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 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..17927c0f9 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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..62a8c68d8 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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..fc08e7709 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 }); From 84b2396d939e8269e6cfbe86dd765a10aed5b4fd Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Wed, 16 Sep 2026 21:58:25 +0000 Subject: [PATCH 6/7] perf(aiur): remove the intermediate u32 comparison carry constraint Use b + c = a + carry * 2^32 with c = a.wrapping_sub(b), returning the whole-word carry directly. Keep all six u16 range checks and both input recomposition constraints, and constrain the carry to be boolean once. Update execution, witnesses, and generated executors together. Extend supplied-trace tests to cover each limb bound and Goldilocks wraparound. Validated Aiur Rust tests, Lean integration suites, full IxVM tests, codegen checks, formatting, and strict workspace Clippy. All 83 kernel FFT pins and the shard pin are unchanged. --- Ix/Aiur/Stages/Codegen.lean | 2 +- crates/aiur/src/constraints.rs | 47 ++--- crates/aiur/src/execute.rs | 2 +- .../aiur/src/synthesis/tests/u32_compare.rs | 20 +- crates/aiur/src/trace.rs | 2 +- crates/ixvm-codegen/src/aiur_ix_aggr.rs | 28 +-- crates/ixvm-codegen/src/aiur_ixvm.rs | 176 +++++++++--------- crates/ixvm-codegen/src/aiur_multi_stark.rs | 30 +-- 8 files changed, 157 insertions(+), 150 deletions(-) diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean index 53c481bfc..c70ef281c 100644 --- a/Ix/Aiur/Stages/Codegen.lean +++ b/Ix/Aiur/Stages/Codegen.lean @@ -621,7 +621,7 @@ 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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1);" ++ + 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);" ++ diff --git a/crates/aiur/src/constraints.rs b/crates/aiur/src/constraints.rs index 8054d5328..83ecd7c31 100644 --- a/crates/aiur/src/constraints.rs +++ b/crates/aiur/src/constraints.rs @@ -37,8 +37,6 @@ fn konst(value: G) -> Expr { /// `256⁻¹` in the Goldilocks field. The field inversion is expensive, so it is /// computed once and reused by the byte carry-chain constraints. static INV_256: LazyLock = LazyLock::new(|| G::from_u64(256).inverse()); -/// `65536⁻¹` for the two-limb u32 comparison carry chain. -static INV_65536: LazyLock = LazyLock::new(|| G::from_u64(65536).inverse()); /// Constant expression for `(2^32)⁻¹`, built once from its Goldilocks /// value and cloned into every virtual u32 carry. static INV_2_POW_32_EXPR: LazyLock = @@ -738,34 +736,39 @@ impl Op { }, Op::U32LessThan(x_idx, y_idx) => { // Bound a, b and the witness c to u32 values with two u16 limbs each. - // The boolean carry chain establishes the integer relation - // a + c + 1 = b + carry * 2^32. - // Since 0 <= c < 2^32, a < b iff the final carry is zero. The +1 - // makes equality return false. All sums are far below Goldilocks p. + // The whole-word carry establishes the integer relation + // b + c = a + carry * 2^32. + // With c = (a - b) mod 2^32, a < b iff the carry is one; equality + // gives c = carry = 0. The bounded integer relation cannot wrap p. // Six scalar range lookups use the shared table's u16 channel. let a = state.map[*x_idx].0.clone(); let b = state.map[*y_idx].0.clone(); - let x: [Expr; 2] = array::from_fn(|_| state.next_auxiliary()); - let y: [Expr; 2] = array::from_fn(|_| state.next_auxiliary()); - let z: [Expr; 2] = array::from_fn(|_| state.next_auxiliary()); + 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))); - state.constraints.zeros.push(sel.clone() * (b - recompose(&z))); - - let mut carry = konst(G::ONE); - for k in 0..2 { - carry = (x[k].clone() + y[k].clone() + carry - z[k].clone()) - * konst(*INV_65536); - state.constraints.zeros.push( - sel.clone() * carry.clone() * (carry.clone() - konst(G::ONE)), - ); - } - for limb in x.into_iter().chain(y).chain(z) { + state + .constraints + .zeros + .push(sel.clone() * (a.clone() - recompose(&a_limbs))); + state + .constraints + .zeros + .push(sel.clone() * (b.clone() - recompose(&b_limbs))); + + // Inputs are affine after multiplication materialization. Use the + // whole words directly: this carry is an expression, not a column. + let carry = (b + recompose(&c_limbs) - a) * INV_2_POW_32_EXPR.clone(); + state + .constraints + .zeros + .push(sel.clone() * carry.clone() * (carry.clone() - konst(G::ONE))); + for limb in a_limbs.into_iter().chain(c_limbs).chain(b_limbs) { state.range_u16(sel, limb); } - state.map.push((konst(G::ONE) - carry, 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 c8dd79889..9a6ae7a4a 100644 --- a/crates/aiur/src/execute.rs +++ b/crates/aiur/src/execute.rs @@ -567,7 +567,7 @@ impl Function { let result = G::from_bool(a_u32 < b_u32); map.push(result); if !unconstrained { - let c_u32 = b_u32.wrapping_sub(a_u32).wrapping_sub(1); + let c_u32 = a_u32.wrapping_sub(b_u32); for word in [a_u32, c_u32, b_u32] { record .bytes2_queries diff --git a/crates/aiur/src/synthesis/tests/u32_compare.rs b/crates/aiur/src/synthesis/tests/u32_compare.rs index 9a5af2b4a..463fbfeda 100644 --- a/crates/aiur/src/synthesis/tests/u32_compare.rs +++ b/crates/aiur/src/synthesis/tests/u32_compare.rs @@ -62,7 +62,7 @@ fn honest_row( let aux = 2 + layout.selectors; row[aux] = G::ONE; let start = aux + 1; - let c = b.wrapping_sub(a).wrapping_sub(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); @@ -210,7 +210,7 @@ fn u32_compare_proofs_and_decoded_keys_cover_boundaries_and_partitions() { let (table, _) = Bytes2.witness_data(&record, &system.slot_arg_widths(byte_circuit)); let mut expected = vec![G::ZERO; 65_536]; - for word in [a, b.wrapping_sub(a).wrapping_sub(1), b] { + 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; } @@ -248,14 +248,18 @@ fn u32_compare_proofs_and_decoded_keys_cover_boundaries_and_partitions() { #[test] fn u32_compare_supplied_out_of_range_limbs_fail_lookup_verification() { - // These witnesses satisfy every local polynomial, including both carry - // bits. Each missing u16 bound would admit an invalid input or a false + // 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, 0, 0, 1, 0], false), - (0, 1_u64 << 32, [0, 0, 65535, 65535, 0, 65536], true), - (1, 2, [1, 0, 0, 65536, 2, 0], false), - (0, 0, [0, 0, 65535, -1, 0, 0], true), + (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(); diff --git a/crates/aiur/src/trace.rs b/crates/aiur/src/trace.rs index 6ff17360e..b4813a1bf 100644 --- a/crates/aiur/src/trace.rs +++ b/crates/aiur/src/trace.rs @@ -638,7 +638,7 @@ 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 c_u32 = b_u32.wrapping_sub(a_u32).wrapping_sub(1); + 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] { diff --git a/crates/ixvm-codegen/src/aiur_ix_aggr.rs b/crates/ixvm-codegen/src/aiur_ix_aggr.rs index 17927c0f9..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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 62a8c68d8..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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = { 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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = { 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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = { 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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = { 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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = { 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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = { 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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = { 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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = { 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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = { 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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = { 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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = { 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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = { 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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = { 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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = { 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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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 = { 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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 fc08e7709..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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); 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_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 }); From eaf84e05745a4b1dc222104a7400764768358734 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Wed, 16 Sep 2026 03:04:31 +0000 Subject: [PATCH 7/7] test(aiur): refresh FFT pins for independent optimizations Measure the Ixon v3 programs from main (519d2c49) against the independent Aiur optimizations, then update all 83 kernel pins and the shard pin. Keep the upstream fixtures and change only their measured costs. Every measured cost decreases: kernel cases by 6.6-16.3%, Nat.add_comm by 11.0%, and the shard pipeline by 9.0%. These measure modeled FFT work, not wall time. The whole-word carry simplification does not reduce FFT costs further. The measurement run passes every non-cost assertion, including generated executor parity checks. No IxVM optimization or cycle defense from #631 is included. Co-authored-by: John C. Burnham --- Tests/Ix/IxVM.lean | 166 ++++++++++++++++++++++----------------------- Tests/Main.lean | 4 +- 2 files changed, 85 insertions(+), 85 deletions(-) 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])]) []),