diff --git a/.github/benchmark_projects.yml b/.github/benchmark_projects.yml index cf206a1c744..7824089e1f8 100644 --- a/.github/benchmark_projects.yml +++ b/.github/benchmark_projects.yml @@ -1,102 +1,102 @@ define: &AZ_COMMIT df8d413b7053aabc9807c8835c270c1f53c45d8f projects: - private-kernel-inner: - repo: AztecProtocol/aztec-packages - ref: *AZ_COMMIT - path: noir-projects/noir-protocol-circuits/crates/private-kernel-inner - num_runs: 5 - compilation-timeout: 3.0 - execution-timeout: 0.08 - compilation-memory-limit: 350 - execution-memory-limit: 250 - private-kernel-tail: - repo: AztecProtocol/aztec-packages - ref: *AZ_COMMIT - path: noir-projects/noir-protocol-circuits/crates/private-kernel-tail - num_runs: 5 - timeout: 4 - compilation-timeout: 3 - execution-timeout: 0.04 - compilation-memory-limit: 250 - execution-memory-limit: 230 - private-kernel-reset: - repo: AztecProtocol/aztec-packages - ref: *AZ_COMMIT - path: noir-projects/noir-protocol-circuits/crates/private-kernel-reset - num_runs: 5 - timeout: 250 - compilation-timeout: 10 - execution-timeout: 0.35 - compilation-memory-limit: 750 - execution-memory-limit: 300 - rollup-base-private: - repo: AztecProtocol/aztec-packages - ref: *AZ_COMMIT - path: noir-projects/noir-protocol-circuits/crates/rollup-base-private - num_runs: 5 - timeout: 15 - compilation-timeout: 20 - execution-timeout: 1 - compilation-memory-limit: 1600 - execution-memory-limit: 650 - rollup-base-public: - repo: AztecProtocol/aztec-packages - ref: *AZ_COMMIT - path: noir-projects/noir-protocol-circuits/crates/rollup-base-public - num_runs: 5 - timeout: 15 - compilation-timeout: 20 - execution-timeout: 0.75 - compilation-memory-limit: 1700 - execution-memory-limit: 600 - rollup-block-root-empty: - repo: AztecProtocol/aztec-packages - ref: *AZ_COMMIT - path: noir-projects/noir-protocol-circuits/crates/rollup-block-root-empty - cannot_execute: true - num_runs: 5 - timeout: 60 - compilation-timeout: 25 - compilation-memory-limit: 1500 - rollup-block-root-single-tx: - repo: AztecProtocol/aztec-packages - ref: *AZ_COMMIT - path: noir-projects/noir-protocol-circuits/crates/rollup-block-root-single-tx - cannot_execute: true - num_runs: 1 - timeout: 60 - compilation-timeout: 250 - compilation-memory-limit: 10000 - rollup-block-root: - repo: AztecProtocol/aztec-packages - ref: *AZ_COMMIT - path: noir-projects/noir-protocol-circuits/crates/rollup-block-root - num_runs: 1 - timeout: 60 - compilation-timeout: 250 - execution-timeout: 40 - compilation-memory-limit: 10000 - execution-memory-limit: 1900 - rollup-merge: - repo: AztecProtocol/aztec-packages - ref: *AZ_COMMIT - path: noir-projects/noir-protocol-circuits/crates/rollup-merge - num_runs: 5 - timeout: 300 - compilation-timeout: 4 - execution-timeout: 0.01 - compilation-memory-limit: 450 - execution-memory-limit: 450 - rollup-root: - repo: AztecProtocol/aztec-packages - ref: *AZ_COMMIT - path: noir-projects/noir-protocol-circuits/crates/rollup-root - num_runs: 5 - timeout: 300 - compilation-timeout: 2 - execution-timeout: 0.6 - compilation-memory-limit: 500 - execution-memory-limit: 450 + # private-kernel-inner: + # repo: AztecProtocol/aztec-packages + # ref: *AZ_COMMIT + # path: noir-projects/noir-protocol-circuits/crates/private-kernel-inner + # num_runs: 5 + # compilation-timeout: 3.0 + # execution-timeout: 0.08 + # compilation-memory-limit: 350 + # execution-memory-limit: 250 + # private-kernel-tail: + # repo: AztecProtocol/aztec-packages + # ref: *AZ_COMMIT + # path: noir-projects/noir-protocol-circuits/crates/private-kernel-tail + # num_runs: 5 + # timeout: 4 + # compilation-timeout: 3 + # execution-timeout: 0.04 + # compilation-memory-limit: 250 + # execution-memory-limit: 230 + # private-kernel-reset: + # repo: AztecProtocol/aztec-packages + # ref: *AZ_COMMIT + # path: noir-projects/noir-protocol-circuits/crates/private-kernel-reset + # num_runs: 5 + # timeout: 250 + # compilation-timeout: 10 + # execution-timeout: 0.35 + # compilation-memory-limit: 750 + # execution-memory-limit: 300 + # rollup-base-private: + # repo: AztecProtocol/aztec-packages + # ref: *AZ_COMMIT + # path: noir-projects/noir-protocol-circuits/crates/rollup-base-private + # num_runs: 5 + # timeout: 15 + # compilation-timeout: 20 + # execution-timeout: 1 + # compilation-memory-limit: 1600 + # execution-memory-limit: 650 + # rollup-base-public: + # repo: AztecProtocol/aztec-packages + # ref: *AZ_COMMIT + # path: noir-projects/noir-protocol-circuits/crates/rollup-base-public + # num_runs: 5 + # timeout: 15 + # compilation-timeout: 20 + # execution-timeout: 0.75 + # compilation-memory-limit: 1700 + # execution-memory-limit: 600 + # rollup-block-root-empty: + # repo: AztecProtocol/aztec-packages + # ref: *AZ_COMMIT + # path: noir-projects/noir-protocol-circuits/crates/rollup-block-root-empty + # cannot_execute: true + # num_runs: 5 + # timeout: 60 + # compilation-timeout: 25 + # compilation-memory-limit: 1500 + # rollup-block-root-single-tx: + # repo: AztecProtocol/aztec-packages + # ref: *AZ_COMMIT + # path: noir-projects/noir-protocol-circuits/crates/rollup-block-root-single-tx + # cannot_execute: true + # num_runs: 1 + # timeout: 60 + # compilation-timeout: 250 + # compilation-memory-limit: 10000 + # rollup-block-root: + # repo: AztecProtocol/aztec-packages + # ref: *AZ_COMMIT + # path: noir-projects/noir-protocol-circuits/crates/rollup-block-root + # num_runs: 1 + # timeout: 60 + # compilation-timeout: 250 + # execution-timeout: 40 + # compilation-memory-limit: 10000 + # execution-memory-limit: 1900 + # rollup-merge: + # repo: AztecProtocol/aztec-packages + # ref: *AZ_COMMIT + # path: noir-projects/noir-protocol-circuits/crates/rollup-merge + # num_runs: 5 + # timeout: 300 + # compilation-timeout: 4 + # execution-timeout: 0.01 + # compilation-memory-limit: 450 + # execution-memory-limit: 450 + # rollup-root: + # repo: AztecProtocol/aztec-packages + # ref: *AZ_COMMIT + # path: noir-projects/noir-protocol-circuits/crates/rollup-root + # num_runs: 5 + # timeout: 300 + # compilation-timeout: 2 + # execution-timeout: 0.6 + # compilation-memory-limit: 500 + # execution-memory-limit: 450 semaphore-depth-10: repo: noir-lang/noir path: test_programs/benchmarks/semaphore_depth_10 diff --git a/.github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/aztec-nr.failures.jsonl b/.github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/aztec-nr.failures.jsonl.does_not_compile similarity index 100% rename from .github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/aztec-nr.failures.jsonl rename to .github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/aztec-nr.failures.jsonl.does_not_compile diff --git a/.github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-contracts.failures.jsonl b/.github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-contracts.failures.jsonl.does_not_compile similarity index 100% rename from .github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-contracts.failures.jsonl rename to .github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-contracts.failures.jsonl.does_not_compile diff --git a/.github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/blob.failures.jsonl b/.github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/blob.failures.jsonl.does_not_compile similarity index 100% rename from .github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/blob.failures.jsonl rename to .github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/blob.failures.jsonl.does_not_compile diff --git a/.github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/parity-lib.failures.jsonl b/.github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/parity-lib.failures.jsonl.does_not_compile similarity index 100% rename from .github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/parity-lib.failures.jsonl rename to .github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/parity-lib.failures.jsonl.does_not_compile diff --git a/.github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/private-kernel-lib.failures.jsonl b/.github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/private-kernel-lib.failures.jsonl.does_not_compile similarity index 100% rename from .github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/private-kernel-lib.failures.jsonl rename to .github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/private-kernel-lib.failures.jsonl.does_not_compile diff --git a/.github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/reset-kernel-lib.failures.jsonl b/.github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/reset-kernel-lib.failures.jsonl.does_not_compile similarity index 100% rename from .github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/reset-kernel-lib.failures.jsonl rename to .github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/reset-kernel-lib.failures.jsonl.does_not_compile diff --git a/.github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/rollup-lib.failures.jsonl b/.github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/rollup-lib.failures.jsonl.does_not_compile similarity index 100% rename from .github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/rollup-lib.failures.jsonl rename to .github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/rollup-lib.failures.jsonl.does_not_compile diff --git a/.github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/types.failures.jsonl b/.github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/types.failures.jsonl.does_not_compile similarity index 100% rename from .github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/types.failures.jsonl rename to .github/critical_libraries_status/AztecProtocol/aztec-packages/noir-projects/noir-protocol-circuits/crates/types.failures.jsonl.does_not_compile diff --git a/.github/critical_libraries_status/noir-lang/noir-bignum/.failures.jsonl b/.github/critical_libraries_status/noir-lang/noir-bignum/.failures.jsonl.does_not_compile similarity index 100% rename from .github/critical_libraries_status/noir-lang/noir-bignum/.failures.jsonl rename to .github/critical_libraries_status/noir-lang/noir-bignum/.failures.jsonl.does_not_compile diff --git a/.github/critical_libraries_status/noir-lang/noir_bigcurve/.failures.jsonl b/.github/critical_libraries_status/noir-lang/noir_bigcurve/.failures.jsonl.does_not_compile similarity index 100% rename from .github/critical_libraries_status/noir-lang/noir_bigcurve/.failures.jsonl rename to .github/critical_libraries_status/noir-lang/noir_bigcurve/.failures.jsonl.does_not_compile diff --git a/.github/critical_libraries_status/noir-lang/sha256/.failures.jsonl b/.github/critical_libraries_status/noir-lang/sha256/.failures.jsonl.does_not_compile similarity index 100% rename from .github/critical_libraries_status/noir-lang/sha256/.failures.jsonl rename to .github/critical_libraries_status/noir-lang/sha256/.failures.jsonl.does_not_compile diff --git a/.github/workflows/test-js-packages.yml b/.github/workflows/test-js-packages.yml index 1b72941aaf2..5b9d051ae0b 100644 --- a/.github/workflows/test-js-packages.yml +++ b/.github/workflows/test-js-packages.yml @@ -614,36 +614,36 @@ jobs: exit 1 fi - compile-noir-contracts: - needs: [build-nargo] - runs-on: ubuntu-22.04 - timeout-minutes: 30 - name: Compile `noir-contracts` zero inliner aggressiveness - steps: - - name: Checkout - uses: actions/checkout@v4 - with: - path: noir-repo - - - name: Checkout - uses: actions/checkout@v4 - with: - repository: AztecProtocol/aztec-packages - path: test-repo - - - name: Download nargo binary - uses: ./noir-repo/.github/actions/download-nargo - - - name: Remove requirements on compiler version - working-directory: ./test-repo - run: | - # Github actions seems to not expand "**" in globs by default. - shopt -s globstar - sed -i '/^compiler_version/d' ./**/Nargo.toml - - - name: Run nargo compile - working-directory: ./test-repo/noir-projects/noir-contracts - run: nargo compile --inliner-aggressiveness 0 + # compile-noir-contracts: + # needs: [build-nargo] + # runs-on: ubuntu-22.04 + # timeout-minutes: 30 + # name: Compile `noir-contracts` zero inliner aggressiveness + # steps: + # - name: Checkout + # uses: actions/checkout@v4 + # with: + # path: noir-repo + + # - name: Checkout + # uses: actions/checkout@v4 + # with: + # repository: AztecProtocol/aztec-packages + # path: test-repo + + # - name: Download nargo binary + # uses: ./noir-repo/.github/actions/download-nargo + + # - name: Remove requirements on compiler version + # working-directory: ./test-repo + # run: | + # # Github actions seems to not expand "**" in globs by default. + # shopt -s globstar + # sed -i '/^compiler_version/d' ./**/Nargo.toml + + # - name: Run nargo compile + # working-directory: ./test-repo/noir-projects/noir-contracts + # run: nargo compile --inliner-aggressiveness 0 upload_critical_library_report: name: Upload critical library report @@ -711,7 +711,7 @@ jobs: - test-integration-node - test-integration-browser - test-examples - - compile-noir-contracts + # - compile-noir-contracts steps: - name: Report overall success diff --git a/acvm-repo/brillig_vm/src/arithmetic.rs b/acvm-repo/brillig_vm/src/arithmetic.rs index c6a143b5dfd..4e658dde137 100644 --- a/acvm-repo/brillig_vm/src/arithmetic.rs +++ b/acvm-repo/brillig_vm/src/arithmetic.rs @@ -5,16 +5,18 @@ use std::ops::{BitAnd, BitOr, BitXor, Shl, Shr}; use acir::AcirField; use acir::brillig::{BinaryFieldOp, BinaryIntOp, BitSize, IntegerBitSize}; use num_bigint::BigUint; -use num_traits::{CheckedDiv, WrappingAdd, WrappingMul, WrappingSub, Zero}; +use num_traits::{CheckedDiv, ToPrimitive, WrappingAdd, WrappingMul, WrappingSub, Zero}; use crate::memory::{MemoryTypeError, MemoryValue}; -#[derive(Debug, thiserror::Error)] +#[derive(Debug, PartialEq, thiserror::Error)] pub(crate) enum BrilligArithmeticError { #[error("Bit size for lhs {lhs_bit_size} does not match op bit size {op_bit_size}")] MismatchedLhsBitSize { lhs_bit_size: u32, op_bit_size: u32 }, #[error("Bit size for rhs {rhs_bit_size} does not match op bit size {op_bit_size}")] MismatchedRhsBitSize { rhs_bit_size: u32, op_bit_size: u32 }, + #[error("Attempted to shift by {shift_size} bits on a type of bit size {bit_size}")] + BitshiftOverflow { bit_size: u32, shift_size: u32 }, #[error("Attempted to divide by zero")] DivisionByZero, } @@ -163,43 +165,66 @@ pub(crate) fn evaluate_binary_int_op( } } - BinaryIntOp::Shl | BinaryIntOp::Shr => { - let rhs = rhs.expect_u8().map_err(|error| match error { - MemoryTypeError::MismatchedBitSize { value_bit_size, expected_bit_size } => { - BrilligArithmeticError::MismatchedRhsBitSize { - rhs_bit_size: value_bit_size, - op_bit_size: expected_bit_size, - } - } - _ => unreachable!("MemoryTypeError NotInteger is only produced by to_u128"), - })?; - - match (lhs, bit_size) { - (MemoryValue::U1(lhs), IntegerBitSize::U1) => { - let result = if rhs == 0 { lhs } else { false }; - Ok(MemoryValue::U1(result)) + BinaryIntOp::Shl | BinaryIntOp::Shr => match (lhs, rhs, bit_size) { + (MemoryValue::U1(lhs), MemoryValue::U1(rhs), IntegerBitSize::U1) => { + if rhs { + Err(BrilligArithmeticError::BitshiftOverflow { bit_size: 1, shift_size: 1 }) + } else { + Ok(MemoryValue::U1(lhs)) } - (MemoryValue::U8(lhs), IntegerBitSize::U8) => { + } + (MemoryValue::U8(lhs), MemoryValue::U8(rhs), IntegerBitSize::U8) => { + if rhs < 8 { Ok(MemoryValue::U8(evaluate_binary_int_op_shifts(op, lhs, rhs))) + } else { + Err(BrilligArithmeticError::BitshiftOverflow { + bit_size: 8, + shift_size: rhs as u32, + }) } - (MemoryValue::U16(lhs), IntegerBitSize::U16) => { + } + (MemoryValue::U16(lhs), MemoryValue::U16(rhs), IntegerBitSize::U16) => { + if rhs < 16 { Ok(MemoryValue::U16(evaluate_binary_int_op_shifts(op, lhs, rhs))) + } else { + Err(BrilligArithmeticError::BitshiftOverflow { + bit_size: 8, + shift_size: rhs as u32, + }) } - (MemoryValue::U32(lhs), IntegerBitSize::U32) => { + } + (MemoryValue::U32(lhs), MemoryValue::U32(rhs), IntegerBitSize::U32) => { + if rhs < 32 { Ok(MemoryValue::U32(evaluate_binary_int_op_shifts(op, lhs, rhs))) + } else { + Err(BrilligArithmeticError::BitshiftOverflow { bit_size: 8, shift_size: rhs }) } - (MemoryValue::U64(lhs), IntegerBitSize::U64) => { + } + (MemoryValue::U64(lhs), MemoryValue::U64(rhs), IntegerBitSize::U64) => { + if rhs < 64 { Ok(MemoryValue::U64(evaluate_binary_int_op_shifts(op, lhs, rhs))) + } else { + Err(BrilligArithmeticError::BitshiftOverflow { + bit_size: 8, + shift_size: rhs as u32, + }) } - (MemoryValue::U128(lhs), IntegerBitSize::U128) => { + } + (MemoryValue::U128(lhs), MemoryValue::U128(rhs), IntegerBitSize::U128) => { + if rhs < 128 { Ok(MemoryValue::U128(evaluate_binary_int_op_shifts(op, lhs, rhs))) + } else { + Err(BrilligArithmeticError::BitshiftOverflow { + bit_size: 8, + shift_size: rhs as u32, + }) } - _ => Err(BrilligArithmeticError::MismatchedLhsBitSize { - lhs_bit_size: lhs.bit_size().to_u32::(), - op_bit_size: bit_size.into(), - }), } - } + _ => Err(BrilligArithmeticError::MismatchedLhsBitSize { + lhs_bit_size: lhs.bit_size().to_u32::(), + op_bit_size: bit_size.into(), + }), + }, } } @@ -255,19 +280,19 @@ fn evaluate_binary_int_op_cmp(op: &BinaryIntOp, lhs: T, rhs: /// /// # Panics /// If an unsupported operator is provided (i.e., not Shl or Shr). -fn evaluate_binary_int_op_shifts + Zero + Shl + Shr>( +fn evaluate_binary_int_op_shifts + Shr>( op: &BinaryIntOp, lhs: T, - rhs: u8, + rhs: T, ) -> T { match op { BinaryIntOp::Shl => { - let rhs_usize: usize = rhs as usize; - if rhs_usize >= 8 * size_of::() { T::zero() } else { lhs << rhs.into() } + let rhs_usize: usize = rhs.to_usize().expect("Could not convert rhs to usize"); + if rhs_usize >= 8 * size_of::() { T::zero() } else { lhs << rhs } } BinaryIntOp::Shr => { - let rhs_usize: usize = rhs as usize; - if rhs_usize >= 8 * size_of::() { T::zero() } else { lhs >> rhs.into() } + let rhs_usize: usize = rhs.to_usize().expect("Could not convert rhs to usize"); + if rhs_usize >= 8 * size_of::() { T::zero() } else { lhs >> rhs } } _ => unreachable!("Operator not handled by this function: {op:?}"), } @@ -432,4 +457,44 @@ mod tests { evaluate_int_ops(test_ops, BinaryIntOp::Div, bit_size); } + + #[test] + fn shl_test() { + let bit_size = IntegerBitSize::U8; + + let test_ops = + vec![TestParams { a: 1, b: 7, result: 128 }, TestParams { a: 5, b: 7, result: 128 }]; + + evaluate_int_ops(test_ops, BinaryIntOp::Shl, bit_size); + + assert_eq!( + evaluate_binary_int_op( + &BinaryIntOp::Shl, + MemoryValue::::U8(1u8), + MemoryValue::::U8(8u8), + IntegerBitSize::U8 + ), + Err(BrilligArithmeticError::BitshiftOverflow { bit_size: 8, shift_size: 8 }) + ); + } + + #[test] + fn shr_test() { + let bit_size = IntegerBitSize::U8; + + let test_ops = + vec![TestParams { a: 1, b: 0, result: 1 }, TestParams { a: 5, b: 1, result: 2 }]; + + evaluate_int_ops(test_ops, BinaryIntOp::Shr, bit_size); + + assert_eq!( + evaluate_binary_int_op( + &BinaryIntOp::Shr, + MemoryValue::::U8(1u8), + MemoryValue::::U8(8u8), + IntegerBitSize::U8 + ), + Err(BrilligArithmeticError::BitshiftOverflow { bit_size: 8, shift_size: 8 }) + ); + } } diff --git a/compiler/noirc_evaluator/src/ssa/interpreter/errors.rs b/compiler/noirc_evaluator/src/ssa/interpreter/errors.rs index 6a075586965..3e0abc0233c 100644 --- a/compiler/noirc_evaluator/src/ssa/interpreter/errors.rs +++ b/compiler/noirc_evaluator/src/ssa/interpreter/errors.rs @@ -115,8 +115,6 @@ pub enum InternalError { "Invalid bit size of `{bit_size}` given to truncate, maximum size allowed for unsigned values is {MAX_UNSIGNED_BIT_SIZE}" )] InvalidUnsignedTruncateBitSize { bit_size: u32 }, - #[error("Rhs of `{operator}` should be a u8 but found `{rhs_id} = {rhs}`")] - RhsOfBitShiftShouldBeU8 { operator: &'static str, rhs_id: ValueId, rhs: String }, #[error( "Expected {expected_type} value in {instruction} but instead found `{value_id} = {value}`" )] diff --git a/compiler/noirc_evaluator/src/ssa/interpreter/mod.rs b/compiler/noirc_evaluator/src/ssa/interpreter/mod.rs index 5cc3776be51..18e4610de8b 100644 --- a/compiler/noirc_evaluator/src/ssa/interpreter/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/interpreter/mod.rs @@ -1297,34 +1297,62 @@ impl Interpreter<'_, W> { apply_int_binop!(lhs, rhs, binary, std::ops::BitXor::bitxor) } BinaryOp::Shl => { - let Some(rhs) = rhs.as_u8() else { - let rhs = rhs.to_string(); - return Err(internal(InternalError::RhsOfBitShiftShouldBeU8 { - operator: "<<", - rhs_id, - rhs, - })); - }; - - let rhs = rhs as u32; use NumericValue::*; - match lhs { - Field(_) => { + let instruction = + format!("`{}` ({lhs} << {rhs})", display_binary(binary, self.dfg())); + let overflow = InterpreterError::Overflow { operator: BinaryOp::Shl, instruction }; + match (lhs, rhs) { + (Field(_), _) | (_, Field(_)) => { return Err(internal(InternalError::UnsupportedOperatorForType { operator: "<<", typ: "Field", })); } - U1(value) => U1(if rhs == 0 { value } else { false }), - U8(value) => U8(value.checked_shl(rhs).unwrap_or(0)), - U16(value) => U16(value.checked_shl(rhs).unwrap_or(0)), - U32(value) => U32(value.checked_shl(rhs).unwrap_or(0)), - U64(value) => U64(value.checked_shl(rhs).unwrap_or(0)), - U128(value) => U128(value.checked_shl(rhs).unwrap_or(0)), - I8(value) => I8(value.checked_shl(rhs).unwrap_or(0)), - I16(value) => I16(value.checked_shl(rhs).unwrap_or(0)), - I32(value) => I32(value.checked_shl(rhs).unwrap_or(0)), - I64(value) => I64(value.checked_shl(rhs).unwrap_or(0)), + (U1(lhs_value), U1(rhs_value)) => { + U1(if !rhs_value { lhs_value } else { false }) + } + (U8(lhs_value), U8(rhs_value)) => { + U8(lhs_value.checked_shl(rhs_value.into()).unwrap_or(0)) + } + (U16(lhs_value), U16(rhs_value)) => { + U16(lhs_value.checked_shl(rhs_value.into()).unwrap_or(0)) + } + (U32(lhs_value), U32(rhs_value)) => { + U32(lhs_value.checked_shl(rhs_value).unwrap_or(0)) + } + (U64(lhs_value), U64(rhs_value)) => { + let rhs_value: u32 = rhs_value.try_into().map_err(|_| overflow)?; + U64(lhs_value.checked_shl(rhs_value).unwrap_or(0)) + } + (U128(lhs_value), U128(rhs_value)) => { + let rhs_value: u32 = rhs_value.try_into().map_err(|_| overflow)?; + U128(lhs_value.checked_shl(rhs_value).unwrap_or(0)) + } + (I8(lhs_value), I8(rhs_value)) => { + let rhs_value: u32 = rhs_value.try_into().map_err(|_| overflow)?; + I8(lhs_value.checked_shl(rhs_value).unwrap_or(0)) + } + (I16(lhs_value), I16(rhs_value)) => { + let rhs_value: u32 = rhs_value.try_into().map_err(|_| overflow)?; + I16(lhs_value.checked_shl(rhs_value).unwrap_or(0)) + } + (I32(lhs_value), I32(rhs_value)) => { + let rhs_value: u32 = rhs_value.try_into().map_err(|_| overflow)?; + I32(lhs_value.checked_shl(rhs_value).unwrap_or(0)) + } + (I64(lhs_value), I64(rhs_value)) => { + let rhs_value: u32 = rhs_value.try_into().map_err(|_| overflow)?; + I64(lhs_value.checked_shl(rhs_value).unwrap_or(0)) + } + _ => { + return Err(internal(InternalError::MismatchedTypesInBinaryOperator { + lhs: lhs.to_string(), + rhs: rhs.to_string(), + operator: binary.operator, + lhs_id: binary.lhs, + rhs_id: binary.rhs, + })); + } } } BinaryOp::Shr => { @@ -1335,35 +1363,63 @@ impl Interpreter<'_, W> { NumericValue::zero(lhs.get_type()) } }; + let instruction = + format!("`{}` ({lhs} >> {rhs})", display_binary(binary, self.dfg())); + let overflow = InterpreterError::Overflow { operator: BinaryOp::Shr, instruction }; - let Some(rhs) = rhs.as_u8() else { - let rhs = rhs.to_string(); - return Err(internal(InternalError::RhsOfBitShiftShouldBeU8 { - operator: ">>", - rhs_id, - rhs, - })); - }; - - let rhs = rhs as u32; use NumericValue::*; - match lhs { - Field(_) => { + match (lhs, rhs) { + (Field(_), _) | (_, Field(_)) => { return Err(internal(InternalError::UnsupportedOperatorForType { - operator: ">>", + operator: "<<", typ: "Field", })); } - U1(value) => U1(if rhs == 0 { value } else { false }), - U8(value) => value.checked_shr(rhs).map(U8).unwrap_or_else(fallback), - U16(value) => value.checked_shr(rhs).map(U16).unwrap_or_else(fallback), - U32(value) => value.checked_shr(rhs).map(U32).unwrap_or_else(fallback), - U64(value) => value.checked_shr(rhs).map(U64).unwrap_or_else(fallback), - U128(value) => value.checked_shr(rhs).map(U128).unwrap_or_else(fallback), - I8(value) => value.checked_shr(rhs).map(I8).unwrap_or_else(fallback), - I16(value) => value.checked_shr(rhs).map(I16).unwrap_or_else(fallback), - I32(value) => value.checked_shr(rhs).map(I32).unwrap_or_else(fallback), - I64(value) => value.checked_shr(rhs).map(I64).unwrap_or_else(fallback), + (U1(lhs_value), U1(rhs_value)) => { + U1(if !rhs_value { lhs_value } else { false }) + } + (U8(lhs_value), U8(rhs_value)) => { + lhs_value.checked_shr(rhs_value.into()).map(U8).unwrap_or_else(fallback) + } + (U16(lhs_value), U16(rhs_value)) => { + lhs_value.checked_shr(rhs_value.into()).map(U16).unwrap_or_else(fallback) + } + (U32(lhs_value), U32(rhs_value)) => { + lhs_value.checked_shr(rhs_value).map(U32).unwrap_or_else(fallback) + } + (U64(lhs_value), U64(rhs_value)) => { + let rhs_value: u32 = rhs_value.try_into().map_err(|_| overflow)?; + lhs_value.checked_shr(rhs_value).map(U64).unwrap_or_else(fallback) + } + (U128(lhs_value), U128(rhs_value)) => { + let rhs_value: u32 = rhs_value.try_into().map_err(|_| overflow)?; + lhs_value.checked_shr(rhs_value).map(U128).unwrap_or_else(fallback) + } + (I8(lhs_value), I8(rhs_value)) => { + let rhs_value: u32 = rhs_value.try_into().map_err(|_| overflow)?; + lhs_value.checked_shr(rhs_value).map(I8).unwrap_or_else(fallback) + } + (I16(lhs_value), I16(rhs_value)) => { + let rhs_value: u32 = rhs_value.try_into().map_err(|_| overflow)?; + lhs_value.checked_shr(rhs_value).map(I16).unwrap_or_else(fallback) + } + (I32(lhs_value), I32(rhs_value)) => { + let rhs_value: u32 = rhs_value.try_into().map_err(|_| overflow)?; + lhs_value.checked_shr(rhs_value).map(I32).unwrap_or_else(fallback) + } + (I64(lhs_value), I64(rhs_value)) => { + let rhs_value: u32 = rhs_value.try_into().map_err(|_| overflow)?; + lhs_value.checked_shr(rhs_value).map(I64).unwrap_or_else(fallback) + } + _ => { + return Err(internal(InternalError::MismatchedTypesInBinaryOperator { + lhs: lhs.to_string(), + rhs: rhs.to_string(), + operator: binary.operator, + lhs_id: binary.lhs, + rhs_id: binary.rhs, + })); + } } } }; @@ -1472,18 +1528,18 @@ impl Interpreter<'_, W> { BinaryOp::Or => lhs | rhs, BinaryOp::Xor => lhs ^ rhs, BinaryOp::Shl => { - return Err(internal(InternalError::RhsOfBitShiftShouldBeU8 { - operator: "<<", - rhs_id, - rhs: format!("u1 {}", rhs as u8), - })); + if rhs { + false + } else { + lhs + } } BinaryOp::Shr => { - return Err(internal(InternalError::RhsOfBitShiftShouldBeU8 { - operator: ">>", - rhs_id, - rhs: format!("u1 {}", rhs as u8), - })); + if rhs { + false + } else { + lhs + } } }; Ok(Value::Numeric(NumericValue::U1(result))) diff --git a/compiler/noirc_evaluator/src/ssa/interpreter/tests/instructions.rs b/compiler/noirc_evaluator/src/ssa/interpreter/tests/instructions.rs index 90150649c1a..cb805166022 100644 --- a/compiler/noirc_evaluator/src/ssa/interpreter/tests/instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/interpreter/tests/instructions.rs @@ -444,7 +444,7 @@ fn shl() { " acir(inline) fn main f0 { b0(): - v0 = shl i8 3, u8 2 + v0 = shl i8 3, i8 2 return v0 } ", @@ -473,9 +473,9 @@ fn shr_unsigned() { " acir(inline) fn main f0 { b0(): - v0 = shr u16 12, u8 2 - v1 = shr u16 5, u8 1 - v2 = shr u16 5, u8 4 + v0 = shr u16 12, u16 2 + v1 = shr u16 5, u16 1 + v2 = shr u16 5, u16 4 return v0, v1, v2 } ", @@ -491,9 +491,9 @@ fn shr_signed() { " acir(inline) fn main f0 { b0(): - v0 = shr i16 65520, u8 2 - v1 = shr i16 65533, u8 1 - v2 = shr i16 65528, u8 3 + v0 = shr i16 65520, i16 2 + v1 = shr i16 65533, i16 1 + v2 = shr i16 65528, i16 3 return v0, v1, v2 } ", @@ -534,7 +534,7 @@ fn shr_overflow_signed_negative_lhs() { " acir(inline) fn main f0 { b0(): - v0 = shr i8 192, u8 9 + v0 = shr i8 192, i8 9 return v0 } ", @@ -546,21 +546,17 @@ fn shr_overflow_signed_negative_lhs() { } #[test] -/// shr on signed integers does not error on overflow. -/// If the value being shifted is positive we return 0, and -1 if it is negative. -/// See https://github.com/noir-lang/noir/pull/8805. -fn shr_overflow_signed_positive_lhs() { - let value = expect_value( +/// shr on signed integers does error on negative rhs +fn shr_overflow_signed_negative_rhs() { + expect_error( " acir(inline) fn main f0 { b0(): - v0 = shr i8 1, u8 255 + v0 = shr i8 1, i8 -3 return v0 } ", ); - - assert_eq!(value, Value::Numeric(NumericValue::I8(0))); } #[test] diff --git a/compiler/noirc_evaluator/src/ssa/interpreter/tests/mod.rs b/compiler/noirc_evaluator/src/ssa/interpreter/tests/mod.rs index 95aec1c01b1..d295ba84f60 100644 --- a/compiler/noirc_evaluator/src/ssa/interpreter/tests/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/interpreter/tests/mod.rs @@ -1648,7 +1648,7 @@ fn signed_integer_casting() { // fn main() -> pub i8 { // let a: i8 = 28; // let b = (1, -a, 0); - // let mut c = (a + (((b.1 as i64) << (b.2 as u8)) as i8)); + // let mut c = (a + (((b.1 as i64) << (b.2 as i64)) as i8)); // c = -c; // c // } @@ -1665,7 +1665,7 @@ fn signed_integer_casting() { v9 = cast u8 228 as u64 v10 = unchecked_add v8, v9 v11 = cast v10 as i64 - v13 = shl v11, u8 0 + v13 = shl v11, i64 0 v14 = truncate v13 to 64 bits, max_bit_size: 65 v15 = truncate v14 to 8 bits, max_bit_size: 64 v16 = cast v15 as i8 diff --git a/compiler/noirc_evaluator/src/ssa/interpreter/value.rs b/compiler/noirc_evaluator/src/ssa/interpreter/value.rs index 43c0e8eb990..26665d9d701 100644 --- a/compiler/noirc_evaluator/src/ssa/interpreter/value.rs +++ b/compiler/noirc_evaluator/src/ssa/interpreter/value.rs @@ -287,13 +287,6 @@ impl NumericValue { } } - pub(crate) fn as_u8(&self) -> Option { - match self { - NumericValue::U8(value) => Some(*value), - _ => None, - } - } - pub fn from_constant(constant: FieldElement, typ: NumericType) -> IResult { use super::InternalError::{ConstantDoesNotFitInType, UnsupportedNumericType}; use super::InterpreterError::Internal; diff --git a/compiler/noirc_evaluator/src/ssa/ir/dfg/simplify/binary.rs b/compiler/noirc_evaluator/src/ssa/ir/dfg/simplify/binary.rs index e8f848b1b02..a5688108b0a 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/dfg/simplify/binary.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/dfg/simplify/binary.rs @@ -23,9 +23,7 @@ pub(super) fn simplify_binary(binary: &Binary, dfg: &mut DataFlowGraph) -> Simpl let rhs_type = dfg.type_of_value(rhs).unwrap_numeric(); let operator = binary.operator; - if operator != BinaryOp::Shl && operator != BinaryOp::Shr { - assert_eq!(lhs_type, rhs_type, "ICE - Binary instruction operands must have the same type"); - } + assert_eq!(lhs_type, rhs_type, "ICE - Binary instruction operands must have the same type"); let operator = if lhs_type == NumericType::NativeField { // Unchecked operations between fields don't make sense, so we convert those to non-unchecked @@ -294,19 +292,8 @@ pub(super) fn simplify_binary(binary: &Binary, dfg: &mut DataFlowGraph) -> Simpl return SimplifyResult::SimplifiedTo(zero); } } - BinaryOp::Shl => return SimplifyResult::SimplifiedToInstruction(simplified), - BinaryOp::Shr => { - // Bit shifts by constants can be treated as divisions. - if let Some(rhs_const) = rhs_value { - if rhs_const >= FieldElement::from(lhs_type.bit_size() as u128) { - // Shifting by the full width of the operand type, any unsigned `lhs` goes to zero. - if lhs_type.is_unsigned() { - let zero = dfg.make_constant(FieldElement::zero(), lhs_type); - return SimplifyResult::SimplifiedTo(zero); - } - } - return SimplifyResult::SimplifiedToInstruction(simplified); - } + BinaryOp::Shl | BinaryOp::Shr => { + return SimplifyResult::SimplifiedToInstruction(simplified); } }; SimplifyResult::SimplifiedToInstruction(simplified) diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs index 4dc2022cf82..4cbee9f3e10 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs @@ -757,7 +757,7 @@ impl Binary { // for unsigned types (here we assume the type of binary.lhs is the same) dfg.type_of_value(self.rhs).is_unsigned() } - BinaryOp::Div | BinaryOp::Mod => true, + BinaryOp::Div | BinaryOp::Mod | BinaryOp::Shl | BinaryOp::Shr => true, BinaryOp::Add { unchecked: true } | BinaryOp::Sub { unchecked: true } | BinaryOp::Mul { unchecked: true } @@ -765,9 +765,7 @@ impl Binary { | BinaryOp::Lt | BinaryOp::And | BinaryOp::Or - | BinaryOp::Xor - | BinaryOp::Shl - | BinaryOp::Shr => false, + | BinaryOp::Xor => false, } } } diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs index 17268216933..77d7b1e68a4 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs @@ -142,6 +142,15 @@ pub(crate) fn eval_constant_binary_op( return Failure("attempt to divide by zero".to_string()); } + // Check for overflow + if operator == BinaryOp::Shl || operator == BinaryOp::Shr { + let op = "bit-shift"; + + if rhs >= bit_size as u128 { + return Failure(format!("attempt to {op} with overflow")); + } + } + let Some(result) = function(lhs, rhs) else { if let BinaryOp::Shl = operator { return CouldNotEvaluate; @@ -183,7 +192,6 @@ pub(crate) fn eval_constant_binary_op( let Some(rhs) = try_convert_field_element_to_signed_integer(rhs, bit_size) else { return CouldNotEvaluate; }; - let result = function(lhs, rhs); let result = match operator { BinaryOp::Div | BinaryOp::Mod if rhs == 0 => { @@ -194,9 +202,10 @@ pub(crate) fn eval_constant_binary_op( // and the operation should be handled by ACIR generation. return Failure("attempt to divide by zero".to_string()); } - BinaryOp::Shr => { - if rhs >= bit_size as i128 { - if lhs >= 0 { 0 } else { -1 } + BinaryOp::Shr | BinaryOp::Shl => { + if rhs >= (bit_size - 1) as i128 { + let op = binary_op_function_name(operator); + return Failure(format!("attempt to {op} with overflow")); } else { let Some(result) = result else { return CouldNotEvaluate; @@ -286,10 +295,14 @@ pub(crate) fn convert_signed_integer_to_field_element(int: i128, bit_size: u32) // signed to u128 conversion FieldElement::from(int as u128) } else { - // We add an offset of `bit_size` bits to shift the negative values into the range [2^(bitsize-1), 2^bitsize) - assert!(bit_size < 128, "{bit_size} is too large"); - let offset_int = (1i128 << bit_size) + int; - FieldElement::from(offset_int) + let two_complement = match bit_size { + 8 => ((int as i8) as u8) as u128, + 16 => ((int as i16) as u16) as u128, + 32 => ((int as i32) as u32) as u128, + 64 => ((int as i64) as u64) as u128, + _ => unreachable!("ICE - invalid bit size {bit_size} for signed integer"), + }; + FieldElement::from(two_complement) } } @@ -406,7 +419,9 @@ mod test { proptest! { #[test] - fn signed_int_roundtrip(int: i128, bit_size in 1u32..=64) { + fn signed_int_roundtrip(int: i128, bit_size in 0usize..=3) { + let bit_sizes = [8,16,32,64]; + let bit_size = bit_sizes[bit_size]; let int = int % (1i128 << (bit_size - 1)); let int_as_field = convert_signed_integer_to_field_element(int, bit_size); diff --git a/compiler/noirc_evaluator/src/ssa/mod.rs b/compiler/noirc_evaluator/src/ssa/mod.rs index b90576d902f..9d03de192ba 100644 --- a/compiler/noirc_evaluator/src/ssa/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/mod.rs @@ -141,9 +141,9 @@ pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { ), SsaPass::new(Ssa::simplify_cfg, "Simplifying"), SsaPass::new(Ssa::mem2reg, "Mem2Reg"), + SsaPass::new(Ssa::remove_bit_shifts, "Removing Bit Shifts"), SsaPass::new(Ssa::simplify_cfg, "Simplifying"), SsaPass::new(Ssa::flatten_cfg, "Flattening"), - SsaPass::new(Ssa::remove_bit_shifts, "Removing Bit Shifts"), // Run mem2reg once more with the flattened CFG to catch any remaining loads/stores SsaPass::new(Ssa::mem2reg, "Mem2Reg"), // Run the inlining pass again to handle functions with `InlineType::NoPredicates`. diff --git a/compiler/noirc_evaluator/src/ssa/opt/as_slice_length.rs b/compiler/noirc_evaluator/src/ssa/opt/as_slice_length.rs index 9ab5fae53f7..f7c428de0fe 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/as_slice_length.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/as_slice_length.rs @@ -28,7 +28,7 @@ impl Ssa { impl Function { pub(crate) fn as_slice_optimization(&mut self) { - self.simple_reachable_blocks_optimization(|context| { + self.simple_optimization(|context| { let instruction_id = context.instruction_id; let instruction = context.instruction(); diff --git a/compiler/noirc_evaluator/src/ssa/opt/brillig_array_get_and_set.rs b/compiler/noirc_evaluator/src/ssa/opt/brillig_array_get_and_set.rs index e189f0b5183..52b51aef118 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/brillig_array_get_and_set.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/brillig_array_get_and_set.rs @@ -40,7 +40,7 @@ impl Ssa { impl Function { pub(super) fn brillig_array_get_and_set(&mut self) { - self.simple_reachable_blocks_optimization(|context| { + self.simple_optimization(|context| { let instruction = context.instruction(); match instruction { Instruction::ArrayGet { array, index, offset } => { diff --git a/compiler/noirc_evaluator/src/ssa/opt/check_u128_mul_overflow.rs b/compiler/noirc_evaluator/src/ssa/opt/check_u128_mul_overflow.rs index f964b0cc022..11704d58700 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/check_u128_mul_overflow.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/check_u128_mul_overflow.rs @@ -35,7 +35,7 @@ impl Function { return; } - self.simple_reachable_blocks_optimization(|context| { + self.simple_optimization(|context| { context.insert_current_instruction(); let block_id = context.block_id; diff --git a/compiler/noirc_evaluator/src/ssa/opt/checked_to_unchecked.rs b/compiler/noirc_evaluator/src/ssa/opt/checked_to_unchecked.rs index 2a23f92f2a1..b0ea3606488 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/checked_to_unchecked.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/checked_to_unchecked.rs @@ -28,7 +28,7 @@ impl Function { fn checked_to_unchecked(&mut self) { let mut value_max_num_bits = HashMap::::default(); - self.simple_reachable_blocks_optimization(|context| { + self.simple_optimization(|context| { let instruction = context.instruction(); let Instruction::Binary(binary) = instruction else { return; diff --git a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs index 58429124c55..2a35f00159c 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs @@ -1379,7 +1379,7 @@ mod test { v2 = lt u32 1000, v0 jmpif v2 then: b1, else: b2 b1(): - v4 = shl v0, u8 1 + v4 = shl v0, u32 1 v5 = lt v0, v4 constrain v5 == u1 1 jmp b2() @@ -1387,7 +1387,7 @@ mod test { v7 = lt u32 1000, v0 jmpif v7 then: b3, else: b4 b3(): - v8 = shl v0, u8 1 + v8 = shl v0, u32 1 v9 = lt v0, v8 constrain v9 == u1 1 jmp b4() @@ -1406,10 +1406,10 @@ mod test { brillig(inline) fn main f0 { b0(v0: u32): v2 = lt u32 1000, v0 - v4 = shl v0, u8 1 + v4 = shl v0, u32 1 jmpif v2 then: b1, else: b2 b1(): - v5 = shl v0, u8 1 + v5 = shl v0, u32 1 v6 = lt v0, v5 constrain v6 == u1 1 jmp b2() diff --git a/compiler/noirc_evaluator/src/ssa/opt/expand_signed_checks.rs b/compiler/noirc_evaluator/src/ssa/opt/expand_signed_checks.rs index 2fe50d2f1d6..23344505b8c 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/expand_signed_checks.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/expand_signed_checks.rs @@ -32,7 +32,7 @@ impl Function { pub(crate) fn expand_signed_checks(&mut self) { // TODO: consider whether we can implement this more efficiently in brillig. - self.simple_reachable_blocks_optimization(|context| { + self.simple_optimization(|context| { let instruction_id = context.instruction_id; let instruction = context.instruction(); diff --git a/compiler/noirc_evaluator/src/ssa/opt/make_constrain_not_equal.rs b/compiler/noirc_evaluator/src/ssa/opt/make_constrain_not_equal.rs index aab02cef2c0..6a61a9dcfa9 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/make_constrain_not_equal.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/make_constrain_not_equal.rs @@ -30,7 +30,7 @@ impl Function { return; } - self.simple_reachable_blocks_optimization(|context| { + self.simple_optimization(|context| { let instruction = context.instruction(); let Instruction::Constrain(lhs, rhs, msg) = instruction else { diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs index e68da28311f..3bd7b6f35ab 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs @@ -35,12 +35,7 @@ impl Function { return; } - let block = self.entry_block(); - - // Make sure this optimization runs when there's only one block - assert_eq!(self.dfg[block].successors().count(), 0); - - self.simple_reachable_blocks_optimization(|context| { + self.simple_optimization(|context| { let instruction_id = context.instruction_id; let instruction = context.instruction(); @@ -120,11 +115,10 @@ impl Context<'_, '_, '_> { (max_bit_size, pow) } else { // we use a predicate to nullify the result in case of overflow - let u8_type = NumericType::unsigned(8); - let bit_size_var = self.numeric_constant(FieldElement::from(bit_size as u128), u8_type); + let bit_size_var = self.numeric_constant(FieldElement::from(bit_size as u128), typ); let overflow = self.insert_binary(rhs, BinaryOp::Lt, bit_size_var); let predicate = self.insert_cast(overflow, NumericType::NativeField); - let pow = self.pow(base, rhs); + let pow = self.pow(base, rhs, bit_size.ilog2() + 1); // Unchecked mul because `predicate` will be 1 or 0 ( @@ -171,7 +165,7 @@ impl Context<'_, '_, '_> { BinaryOp::Mul { unchecked: true }, rhs, ); - let pow = self.pow(base, rhs); + let pow = self.pow(base, rhs, bit_size.ilog2() + 1); let pow = self.insert_cast(pow, lhs_typ); if lhs_typ.is_unsigned() { @@ -253,12 +247,7 @@ impl Context<'_, '_, '_> { /// let b = rhs_bits[bit_size - i]; /// r = (r_squared * lhs * b) + (1 - b) * r_squared; /// } - fn pow(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId { - let typ = self.context.dfg.type_of_value(rhs); - let Type::Numeric(NumericType::Unsigned { bit_size }) = typ else { - unreachable!("Value must be unsigned in power operation"); - }; - + fn pow(&mut self, lhs: ValueId, rhs: ValueId, bit_size: u32) -> ValueId { let to_bits = self.context.dfg.import_intrinsic(Intrinsic::ToBits(Endian::Little)); let result_types = vec![Type::Array(Arc::new(vec![Type::bool()]), bit_size)]; @@ -409,7 +398,7 @@ mod tests { let src = " acir(inline) fn main f0 { b0(v0: u32): - v2 = shl v0, u8 2 + v2 = shl v0, u32 2 v3 = truncate v2 to 32 bits, max_bit_size: 33 return v2 } @@ -433,7 +422,7 @@ mod tests { fn removes_shl_with_non_constant_rhs() { let src = " acir(inline) fn main f0 { - b0(v0: u32, v1: u8): + b0(v0: u32, v1: u32): v2 = shl v0, v1 v3 = truncate v2 to 32 bits, max_bit_size: 33 return v2 @@ -444,18 +433,18 @@ mod tests { assert_ssa_snapshot!(ssa, @r" acir(inline) fn main f0 { - b0(v0: u32, v1: u8): - v3 = lt v1, u8 32 + b0(v0: u32, v1: u32): + v3 = lt v1, u32 32 v4 = cast v3 as Field v5 = cast v1 as Field - v7 = call to_le_bits(v5) -> [u1; 8] - v9 = array_get v7, index u32 7 -> u1 + v7 = call to_le_bits(v5) -> [u1; 6] + v9 = array_get v7, index u32 5 -> u1 v10 = not v9 v11 = cast v9 as Field v12 = cast v10 as Field v14 = mul Field 2, v11 v15 = add v12, v14 - v17 = array_get v7, index u32 6 -> u1 + v17 = array_get v7, index u32 4 -> u1 v18 = not v17 v19 = cast v17 as Field v20 = cast v18 as Field @@ -464,7 +453,7 @@ mod tests { v23 = mul v21, Field 2 v24 = mul v23, v19 v25 = add v22, v24 - v27 = array_get v7, index u32 5 -> u1 + v27 = array_get v7, index u32 3 -> u1 v28 = not v27 v29 = cast v27 as Field v30 = cast v28 as Field @@ -473,7 +462,7 @@ mod tests { v33 = mul v31, Field 2 v34 = mul v33, v29 v35 = add v32, v34 - v37 = array_get v7, index u32 4 -> u1 + v37 = array_get v7, index u32 2 -> u1 v38 = not v37 v39 = cast v37 as Field v40 = cast v38 as Field @@ -482,7 +471,7 @@ mod tests { v43 = mul v41, Field 2 v44 = mul v43, v39 v45 = add v42, v44 - v47 = array_get v7, index u32 3 -> u1 + v47 = array_get v7, index u32 1 -> u1 v48 = not v47 v49 = cast v47 as Field v50 = cast v48 as Field @@ -491,7 +480,7 @@ mod tests { v53 = mul v51, Field 2 v54 = mul v53, v49 v55 = add v52, v54 - v57 = array_get v7, index u32 2 -> u1 + v57 = array_get v7, index u32 0 -> u1 v58 = not v57 v59 = cast v57 as Field v60 = cast v58 as Field @@ -500,32 +489,97 @@ mod tests { v63 = mul v61, Field 2 v64 = mul v63, v59 v65 = add v62, v64 - v67 = array_get v7, index u32 1 -> u1 - v68 = not v67 - v69 = cast v67 as Field - v70 = cast v68 as Field - v71 = mul v65, v65 - v72 = mul v71, v70 - v73 = mul v71, Field 2 - v74 = mul v73, v69 - v75 = add v72, v74 - v77 = array_get v7, index u32 0 -> u1 - v78 = not v77 - v79 = cast v77 as Field - v80 = cast v78 as Field - v81 = mul v75, v75 - v82 = mul v81, v80 - v83 = mul v81, Field 2 - v84 = mul v83, v79 - v85 = add v82, v84 - v86 = mul v4, v85 - v87 = cast v0 as Field - v88 = mul v87, v86 - v89 = truncate v88 to 32 bits, max_bit_size: 254 - v90 = cast v89 as u32 - v91 = truncate v90 to 32 bits, max_bit_size: 33 - return v90 + v66 = mul v4, v65 + v67 = cast v0 as Field + v68 = mul v67, v66 + v69 = truncate v68 to 32 bits, max_bit_size: 254 + v70 = cast v69 as u32 + v71 = truncate v70 to 32 bits, max_bit_size: 33 + return v70 } "); } + + #[test] + fn follows_canonical_block_ordering() { + let src = r#" + acir(inline) predicate_pure fn main f0 { + b0(): + constrain u1 0 == u1 1, "attempt to bit-shift with overflow" + v4 = shr u8 1, u8 98 + v6 = eq v4, u8 0 + jmpif v6 then: b7, else: b8 + b1(): + jmp b3() + b2(): + jmp b3() + b3(): + v11 = eq v9, u8 1 + jmpif v11 then: b4, else: b5 + b4(): + jmp b6() + b5(): + jmp b6() + b6(): + return + b7(): + jmp b9() + b8(): + jmp b9() + b9(): + v7 = eq v4, u8 1 + jmpif v7 then: b10, else: b11 + b10(): + jmp b12() + b11(): + jmp b12() + b12(): + v9 = shr u8 1, u8 99 + v10 = eq v9, u8 0 + jmpif v10 then: b1, else: b2 + } + "#; + let ssa = Ssa::from_str(src).unwrap(); + let ssa = ssa.remove_bit_shifts(); + + // We expect v9 in b3 to be resolved to `u8 0`. Even though b12 has a higher value, + // it comes before b3 in the block ordering. + assert_ssa_snapshot!(ssa, @r#" + acir(inline) predicate_pure fn main f0 { + b0(): + constrain u1 0 == u1 1, "attempt to bit-shift with overflow" + v2 = make_array [u1 0, u1 0, u1 0, u1 0] : [u1; 4] + v4 = eq u8 0, u8 0 + jmpif v4 then: b7, else: b8 + b1(): + jmp b3() + b2(): + jmp b3() + b3(): + v9 = eq u8 0, u8 1 + jmpif v9 then: b4, else: b5 + b4(): + jmp b6() + b5(): + jmp b6() + b6(): + return + b7(): + jmp b9() + b8(): + jmp b9() + b9(): + v6 = eq u8 0, u8 1 + jmpif v6 then: b10, else: b11 + b10(): + jmp b12() + b11(): + jmp b12() + b12(): + v7 = make_array [u1 0, u1 0, u1 0, u1 0] : [u1; 4] + v8 = eq u8 0, u8 0 + jmpif v8 then: b1, else: b2 + } + "#); + } } diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs index 25f063fcd94..b5ae0b786af 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs @@ -49,7 +49,7 @@ impl Function { let mut previous_block = None; - self.simple_reachable_blocks_optimization(|context| { + self.simple_optimization(|context| { if Some(context.block_id) != previous_block { active_condition = one; last_side_effects_enabled_instruction = None; diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs index c734c82a728..bd49a4752da 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs @@ -67,7 +67,7 @@ impl Context { // Make sure this optimization runs when there's only one block assert_eq!(function.dfg[block].successors().count(), 0); - function.simple_reachable_blocks_optimization_result(|context| { + function.simple_optimization_result(|context| { let instruction_id = context.instruction_id; let instruction = context.instruction(); diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_truncate_after_range_check.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_truncate_after_range_check.rs index 0a0b709a494..cdc8183b78b 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_truncate_after_range_check.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_truncate_after_range_check.rs @@ -23,7 +23,7 @@ impl Function { // Keeps the minimum bit size a value was range-checked against let mut range_checks: HashMap = HashMap::default(); - self.simple_reachable_blocks_optimization(|context| { + self.simple_optimization(|context| { let instruction_id = context.instruction_id; let instruction = context.instruction(); diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index 4ea93cabf06..0eafa716571 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -60,7 +60,7 @@ impl Function { let one = self.dfg.make_constant(1_u32.into(), NumericType::bool()); let mut side_effects_condition = one; - self.simple_reachable_blocks_optimization(|context| { + self.simple_optimization(|context| { let block_id = context.block_id; if current_block_id != Some(block_id) { diff --git a/compiler/noirc_evaluator/src/ssa/opt/simple_optimization.rs b/compiler/noirc_evaluator/src/ssa/opt/simple_optimization.rs index a0c1d0d141d..de779d93ab5 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/simple_optimization.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/simple_optimization.rs @@ -9,8 +9,8 @@ use crate::{ dfg::{DataFlowGraph, InsertInstructionResult}, function::Function, instruction::{Instruction, InstructionId}, - types::NumericType, - types::Type, + post_order::PostOrder, + types::{NumericType, Type}, value::{ValueId, ValueMapping}, }, }; @@ -18,7 +18,7 @@ use crate::{ impl Function { /// Performs a simple optimization according to the given callback. /// - /// The function's [`Function::reachable_blocks`] are traversed in turn, and instructions in those blocks + /// The function's reverse [post order][PostOrder] are traversed in turn, and instructions in those blocks /// are then traversed in turn. For each one, `f` will be called with a context. /// /// The current instruction will be inserted at the end of the callback given to `mutate` unless @@ -29,11 +29,11 @@ impl Function { /// /// `replace_value` can be used to replace a value with another one. This substitution will be /// performed in all subsequent instructions. - pub(crate) fn simple_reachable_blocks_optimization(&mut self, mut f: F) + pub(crate) fn simple_optimization(&mut self, mut f: F) where F: FnMut(&mut SimpleOptimizationContext<'_, '_>), { - self.simple_reachable_blocks_optimization_result(move |context| { + self.simple_optimization_result(move |context| { f(context); Ok(()) }) @@ -43,7 +43,7 @@ impl Function { /// Performs a simple optimization according to the given callback, returning early if /// an error occurred. /// - /// The function's [`Function::reachable_blocks`] are traversed in turn, and instructions in those blocks + /// The function's reverse [post order][PostOrder] are traversed in turn, and instructions in those blocks /// are then traversed in turn. For each one, `f` will be called with a context. /// /// The current instruction will be inserted at the end of the callback given to `mutate` unless @@ -54,17 +54,16 @@ impl Function { /// /// `replace_value` can be used to replace a value with another one. This substitution will be /// performed in all subsequent instructions. - pub(crate) fn simple_reachable_blocks_optimization_result( - &mut self, - mut f: F, - ) -> RtResult<()> + pub(crate) fn simple_optimization_result(&mut self, mut f: F) -> RtResult<()> where F: FnMut(&mut SimpleOptimizationContext<'_, '_>) -> RtResult<()>, { let mut values_to_replace = ValueMapping::default(); let mut enable_side_effects = self.dfg.make_constant(FieldElement::from(1_u128), NumericType::bool()); - for block_id in self.reachable_blocks() { + let mut reverse_post_order = PostOrder::with_function(self).into_vec(); + reverse_post_order.reverse(); + for block_id in reverse_post_order { let instruction_ids = self.dfg[block_id].take_instructions(); self.dfg[block_id].instructions_mut().reserve(instruction_ids.len()); for instruction_id in &instruction_ids { diff --git a/compiler/noirc_evaluator/src/ssa/parser/tests.rs b/compiler/noirc_evaluator/src/ssa/parser/tests.rs index d3963c0f852..f6ee84a9189 100644 --- a/compiler/noirc_evaluator/src/ssa/parser/tests.rs +++ b/compiler/noirc_evaluator/src/ssa/parser/tests.rs @@ -498,7 +498,7 @@ fn test_binary() { let src = format!( " acir(inline) fn main f0 {{ - b0(v0: u32, v1: u8): + b0(v0: u32, v1: u32): v2 = {op} v0, v1 return }} diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs index 3b25bec30b4..f1f818fd7f3 100644 --- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs +++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs @@ -312,88 +312,31 @@ impl<'a> FunctionContext<'a> { Ok(self.builder.numeric_constant(value, numeric_type)) } - /// Insert constraints ensuring that the operation does not overflow the bit size of the result - /// - /// If the result is unsigned, overflow will be checked during acir-gen (cf. issue #4456), except for - /// bit-shifts, because we will convert them to field multiplication - /// - /// If the result is signed, overflow will be checked during SSA optimization. - fn check_overflow( - &mut self, - result: ValueId, - lhs: ValueId, - rhs: ValueId, - operator: BinaryOpKind, - location: Location, - ) -> ValueId { - let result_type = self.builder.current_function.dfg.type_of_value(result).unwrap_numeric(); - match result_type { - NumericType::Signed { bit_size } => { - match operator { - BinaryOpKind::Add | BinaryOpKind::Subtract | BinaryOpKind::Multiply => { - // Overflow check is deferred to ssa pass - result - } - BinaryOpKind::ShiftLeft | BinaryOpKind::ShiftRight => { - self.check_shift_overflow(result, rhs, bit_size, location) - } - _ => unreachable!("operator {} should not overflow", operator), - } - } - NumericType::Unsigned { bit_size } => { - let dfg = &self.builder.current_function.dfg; - let max_lhs_bits = dfg.get_value_max_num_bits(lhs); - - match operator { - BinaryOpKind::Add | BinaryOpKind::Subtract | BinaryOpKind::Multiply => { - // Overflow check is deferred to acir-gen - result - } - BinaryOpKind::ShiftLeft => { - if let Some(rhs_const) = dfg.get_numeric_constant(rhs) { - let bit_shift_size = rhs_const.to_u128() as u32; - - if max_lhs_bits + bit_shift_size <= bit_size { - // `lhs` has been casted up from a smaller type such that shifting it by a constant - // `rhs` is known not to exceed the maximum bit size. - return result; - } - } - - self.check_shift_overflow(result, rhs, bit_size, location); - result - } + /// Insert constraints ensuring that the right-hand side of a bit-shift operation + /// is less than the bit size of the left-hand side. + fn enforce_bitshift_rhs_lt_bit_size(&mut self, rhs: ValueId) { + let one = self.builder.numeric_constant(FieldElement::one(), NumericType::bool()); + let rhs_type = self.builder.current_function.dfg.type_of_value(rhs); - _ => unreachable!("operator {} should not overflow", operator), - } + let assert_message = Some("attempt to bit-shift with overflow".to_owned()); + + let (bit_size, bit_size_field) = match rhs_type { + Type::Numeric(NumericType::Unsigned { bit_size }) => { + (bit_size, FieldElement::from(bit_size)) } - NumericType::NativeField => result, - } - } + Type::Numeric(NumericType::Signed { bit_size }) => { + assert!(bit_size > 1, "ICE - i1 is not a valid type"); - /// Overflow checks for bit-shift - /// We use Rust behavior for bit-shift: - /// If rhs is more or equal than the bit size, then we overflow - /// If not, we do not overflow and shift with 0 when bits are falling out of the bit size - fn check_shift_overflow( - &mut self, - result: ValueId, - rhs: ValueId, - bit_size: u32, - location: Location, - ) -> ValueId { - let one = self.builder.numeric_constant(FieldElement::one(), NumericType::bool()); - assert!(self.builder.current_function.dfg.type_of_value(rhs) == Type::unsigned(8)); + (bit_size, FieldElement::from(bit_size - 1)) + } + _ => unreachable!("check_shift_overflow called with non-numeric type"), + }; - let bit_size_field = FieldElement::from(bit_size as i128); - let max = self.builder.numeric_constant(bit_size_field, NumericType::unsigned(8)); + let unsigned_typ = NumericType::unsigned(bit_size); + let max = self.builder.numeric_constant(bit_size_field, unsigned_typ); + let rhs = self.builder.insert_cast(rhs, unsigned_typ); let overflow = self.builder.insert_binary(rhs, BinaryOp::Lt, max); - self.builder.set_location(location).insert_constrain( - overflow, - one, - Some("attempt to bit-shift with overflow".to_owned().into()), - ); - self.builder.insert_truncate(result, bit_size, bit_size + 1) + self.builder.insert_constrain(overflow, one, assert_message.map(Into::into)); } /// Insert a binary instruction at the end of the current block. @@ -412,18 +355,22 @@ impl<'a> FunctionContext<'a> { std::mem::swap(&mut lhs, &mut rhs); } - let mut result = self.builder.set_location(location).insert_binary(lhs, op, rhs); + self.builder.set_location(location); + + if matches!(operator, BinaryOpKind::ShiftLeft | BinaryOpKind::ShiftRight) { + self.enforce_bitshift_rhs_lt_bit_size(rhs); + }; + + let mut result = self.builder.insert_binary(lhs, op, rhs); // Check for integer overflow - if matches!( - operator, - BinaryOpKind::Add - | BinaryOpKind::Subtract - | BinaryOpKind::Multiply - | BinaryOpKind::ShiftLeft - ) { - result = self.check_overflow(result, lhs, rhs, operator, location); - } + if matches!(operator, |BinaryOpKind::ShiftLeft| BinaryOpKind::ShiftRight) { + let result_type = + self.builder.current_function.dfg.type_of_value(result).unwrap_numeric(); + if let NumericType::Signed { bit_size } = result_type { + result = self.builder.insert_truncate(result, bit_size, bit_size + 1); + } + }; if operator_requires_not(operator) { result = self.builder.insert_not(result); diff --git a/compiler/noirc_evaluator/src/ssa/validation/mod.rs b/compiler/noirc_evaluator/src/ssa/validation/mod.rs index 7c4cb67637d..9171df7df94 100644 --- a/compiler/noirc_evaluator/src/ssa/validation/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/validation/mod.rs @@ -160,18 +160,6 @@ impl<'f> Validator<'f> { panic!("Cannot use `lt` with field elements"); } } - BinaryOp::Shl => { - if !matches!(rhs_type, Type::Numeric(NumericType::Unsigned { bit_size: 8 })) - { - panic!("Right-hand side of `shl` must be u8"); - } - } - BinaryOp::Shr => { - if !matches!(rhs_type, Type::Numeric(NumericType::Unsigned { bit_size: 8 })) - { - panic!("Right-hand side of `shr` must be u8"); - } - } _ => { if lhs_type != rhs_type { panic!( @@ -399,8 +387,10 @@ mod tests { } #[test] - #[should_panic(expected = "Right-hand side of `shr` must be u8")] - fn disallows_shr_with_non_u8() { + #[should_panic( + expected = "Left-hand side and right-hand side of `shr` must have the same type" + )] + fn disallows_shr_with_different_type() { let src = " acir(inline) fn main f0 { b0(): @@ -412,8 +402,10 @@ mod tests { } #[test] - #[should_panic(expected = "Right-hand side of `shl` must be u8")] - fn disallows_shl_with_non_u8() { + #[should_panic( + expected = "Left-hand side and right-hand side of `shl` must have the same type" + )] + fn disallows_shl_with_different_type() { let src = " acir(inline) fn main f0 { b0(): diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs index 3fc7b27df57..984d8a0ea20 100644 --- a/compiler/noirc_frontend/src/elaborator/types.rs +++ b/compiler/noirc_frontend/src/elaborator/types.rs @@ -9,9 +9,9 @@ use crate::{ Generics, Kind, NamedGeneric, ResolvedGeneric, Type, TypeBinding, TypeBindings, UnificationError, ast::{ - AsTraitPath, BinaryOpKind, GenericTypeArgs, Ident, IntegerBitSize, PathKind, UnaryOp, - UnresolvedGeneric, UnresolvedGenerics, UnresolvedType, UnresolvedTypeData, - UnresolvedTypeExpression, WILDCARD_TYPE, + AsTraitPath, BinaryOpKind, GenericTypeArgs, Ident, PathKind, UnaryOp, UnresolvedGeneric, + UnresolvedGenerics, UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression, + WILDCARD_TYPE, }, elaborator::UnstableFeature, hir::{ @@ -1458,20 +1458,6 @@ impl Elaborator<'_> { // Matches on TypeVariable must be first so that we follow any type // bindings. (TypeVariable(int), other) | (other, TypeVariable(int)) => { - if op.kind == BinaryOpKind::ShiftLeft || op.kind == BinaryOpKind::ShiftRight { - self.unify( - rhs_type, - &Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight), - || TypeCheckError::InvalidShiftSize { location }, - ); - let use_impl = if lhs_type.is_numeric_value() { - let integer_type = self.polymorphic_integer(); - self.bind_type_variables_for_infix(lhs_type, op, &integer_type, location) - } else { - true - }; - return Ok((lhs_type.clone(), use_impl)); - } if let TypeBinding::Bound(binding) = &*int.borrow() { return self.infix_operand_type_rules(binding, op, other, location); } @@ -1479,12 +1465,6 @@ impl Elaborator<'_> { Ok((other.clone(), use_impl)) } (Integer(sign_x, bit_width_x), Integer(sign_y, bit_width_y)) => { - if op.kind == BinaryOpKind::ShiftLeft || op.kind == BinaryOpKind::ShiftRight { - if *sign_y != Signedness::Unsigned || *bit_width_y != IntegerBitSize::Eight { - return Err(TypeCheckError::InvalidShiftSize { location }); - } - return Ok((Integer(*sign_x, *bit_width_x), false)); - } if sign_x != sign_y { return Err(TypeCheckError::IntegerSignedness { sign_x: *sign_x, @@ -1535,12 +1515,6 @@ impl Elaborator<'_> { }, (lhs, rhs) => { - if op.kind == BinaryOpKind::ShiftLeft || op.kind == BinaryOpKind::ShiftRight { - if rhs == &Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight) { - return Ok((lhs.clone(), true)); - } - return Err(TypeCheckError::InvalidShiftSize { location }); - } self.unify(lhs, rhs, || TypeCheckError::TypeMismatchWithSource { expected: lhs.clone(), actual: rhs.clone(), diff --git a/compiler/noirc_frontend/src/hir/comptime/errors.rs b/compiler/noirc_frontend/src/hir/comptime/errors.rs index df92f6c4e4a..9e5913f1872 100644 --- a/compiler/noirc_frontend/src/hir/comptime/errors.rs +++ b/compiler/noirc_frontend/src/hir/comptime/errors.rs @@ -521,8 +521,7 @@ impl<'a> From<&'a InterpreterError> for CustomDiagnostic { "+" => "add", "-" => "subtract", "*" => "multiply", - ">>" => "shift right", - "<<" => "shift left", + ">>" | "<<" => "bit-shift", _ => operator, }; format!("Attempt to {operator} with overflow") diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter/infix.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter/infix.rs index 27619528bfd..9e3280131a6 100644 --- a/compiler/noirc_frontend/src/hir/comptime/interpreter/infix.rs +++ b/compiler/noirc_frontend/src/hir/comptime/interpreter/infix.rs @@ -125,25 +125,6 @@ pub(super) fn evaluate_infix( }; } - /// Generate matches for bit shifting, which in Noir only accepts `u8` for RHS. - macro_rules! match_bitshift { - (($lhs_value:ident as $lhs:ident $op:literal $rhs_value:ident as $rhs:ident) => $expr:expr) => { - match_values! { - ($lhs_value as $lhs $op $rhs_value as $rhs) { - (I8, U8) to I8 => $expr, - (I16, U8) to I16 => $expr, - (I32, U8) to I32 => $expr, - (I64, U8) to I64 => $expr, - (U8, U8) to U8 => $expr, - (U16, U8) to U16 => $expr, - (U32, U8) to U32 => $expr, - (U64, U8) to U64 => $expr, - (U128, U8) to U128 => $expr, - } - } - }; - } - #[allow(clippy::bool_comparison)] match operator.kind { BinaryOpKind::Add => match_arithmetic! { @@ -201,26 +182,11 @@ pub(super) fn evaluate_infix( BinaryOpKind::Xor => match_bitwise! { (lhs_value as lhs "^" rhs_value as rhs) => lhs ^ rhs }, - BinaryOpKind::ShiftRight => { - let is_negative = lhs_value.is_negative(); - match_bitshift! { - (lhs_value as lhs ">>" rhs_value as rhs) => { - Some( - lhs.checked_shr(rhs.into()) - .unwrap_or( - // fallback based on whether we have a negative value - if is_negative { - // !0 = -1 for signed types - !0 - } else { - 0 - }) - ) - } - } - } - BinaryOpKind::ShiftLeft => match_bitshift! { - (lhs_value as lhs "<<" rhs_value as rhs) => lhs.checked_shl(rhs.into()) + BinaryOpKind::ShiftRight => match_integer! { + (lhs_value as lhs ">>" rhs_value as rhs) => lhs.checked_shr(rhs as u32) + }, + BinaryOpKind::ShiftLeft => match_integer! { + (lhs_value as lhs "<<" rhs_value as rhs) => lhs.checked_shl(rhs as u32) }, BinaryOpKind::Modulo => match (&lhs_value, &rhs_value) { (Value::I8(i8::MIN), Value::I8(-1)) => Ok(Value::I8(0)), @@ -344,17 +310,16 @@ mod test { 64 >> 255 } "#; - let result = interpret(src); - // 255 % 64 == 63, so 64 >> 63 => 0 - assert_eq!(result, Value::U64(0)); + let result = interpret_expect_error(src); + assert!(matches!(result, InterpreterError::BinaryOperationOverflow { operator: ">>", .. })); let src = " comptime fn main() -> pub u32 { 1360887544 >> 141 } "; - let result = interpret(src); - assert_eq!(result, Value::U32(0)); + let result = interpret_expect_error(src); + assert!(matches!(result, InterpreterError::BinaryOperationOverflow { operator: ">>", .. })); } #[test] @@ -372,17 +337,16 @@ mod test { -64 >> 255 } "; - let result = interpret(src); - // 255 % 64 == 63, so 64 >> 63 => -1 - assert_eq!(result, Value::I64(-1)); + let result = interpret_expect_error(src); + assert!(matches!(result, InterpreterError::BinaryOperationOverflow { operator: ">>", .. })); let src = " comptime fn main() -> pub i32 { -1360887544 >> 141 } "; - let result = interpret(src); - assert_eq!(result, Value::I32(-1)); + let result = interpret_expect_error(src); + assert!(matches!(result, InterpreterError::BinaryOperationOverflow { operator: ">>", .. })); } #[test] @@ -400,16 +364,16 @@ mod test { 64 >> 255 } "; - let result = interpret(src); - assert_eq!(result, Value::I64(0)); + let result = interpret_expect_error(src); + assert!(matches!(result, InterpreterError::BinaryOperationOverflow { operator: ">>", .. })); let src = " comptime fn main() -> pub i32 { 1360887544 >> 141 } "; - let result = interpret(src); - assert_eq!(result, Value::I32(0)); + let result = interpret_expect_error(src); + assert!(matches!(result, InterpreterError::BinaryOperationOverflow { operator: ">>", .. })); } #[test] diff --git a/docs/docs/noir/concepts/ops.md b/docs/docs/noir/concepts/ops.md index fb2d5c57b5d..b72ce21e7fd 100644 --- a/docs/docs/noir/concepts/ops.md +++ b/docs/docs/noir/concepts/ops.md @@ -31,8 +31,8 @@ sidebar_position: 3 | ^ | XOR two private input types together | Types must be integer | | & | AND two private input types together | Types must be integer | | \| | OR two private input types together | Types must be integer | -| \<\< | Left shift an integer by another integer amount | Types must be integer, shift must be u8 | -| >> | Right shift an integer by another integer amount | Types must be integer, shift must be u8 | +| \<\< | Left shift an integer by another integer amount | Types must be integer | +| >> | Right shift an integer by another integer amount | Types must be integer | | ! | Bitwise not of a value | Type must be integer or boolean | | \< | returns a bool if one value is less than the other | Upper bound must have a known bit size | | \<= | returns a bool if one value is less than or equal to the other | Upper bound must have a known bit size | @@ -63,6 +63,10 @@ fn main(x : Field) { > `x & x` would not compile as `x` is a `Field` and not an integer type. +Bit shifts left: `<<`, or right: `>>` require the right hand side operand to be less that the bit size `s` of the operands type: +`x << y` or `x >> y` overflow if `x,y` are unsigned and `y >= s` +`x << y` or `x >> y` overflow if `x,y` are signed and `y >= s-1` + ### Logical Operators Noir has no support for the logical operators `||` and `&&`. This is because encoding the diff --git a/noir_stdlib/src/ops/bit.nr b/noir_stdlib/src/ops/bit.nr index 3b1f99430cd..d242a375d68 100644 --- a/noir_stdlib/src/ops/bit.nr +++ b/noir_stdlib/src/ops/bit.nr @@ -258,27 +258,27 @@ impl BitXor for i64 { // docs:start:shl-trait pub trait Shl { - fn shl(self, other: u8) -> Self; + fn shl(self, other: Self) -> Self; } // docs:end:shl-trait impl Shl for u128 { - fn shl(self, other: u8) -> u128 { + fn shl(self, other: u128) -> u128 { self << other } } impl Shl for u64 { - fn shl(self, other: u8) -> u64 { + fn shl(self, other: u64) -> u64 { self << other } } impl Shl for u32 { - fn shl(self, other: u8) -> u32 { + fn shl(self, other: u32) -> u32 { self << other } } impl Shl for u16 { - fn shl(self, other: u8) -> u16 { + fn shl(self, other: u16) -> u16 { self << other } } @@ -288,55 +288,55 @@ impl Shl for u8 { } } impl Shl for u1 { - fn shl(self, other: u8) -> u1 { + fn shl(self, other: u1) -> u1 { self << other } } impl Shl for i8 { - fn shl(self, other: u8) -> i8 { + fn shl(self, other: i8) -> i8 { self << other } } impl Shl for i16 { - fn shl(self, other: u8) -> i16 { + fn shl(self, other: i16) -> i16 { self << other } } impl Shl for i32 { - fn shl(self, other: u8) -> i32 { + fn shl(self, other: i32) -> i32 { self << other } } impl Shl for i64 { - fn shl(self, other: u8) -> i64 { + fn shl(self, other: i64) -> i64 { self << other } } // docs:start:shr-trait pub trait Shr { - fn shr(self, other: u8) -> Self; + fn shr(self, other: Self) -> Self; } // docs:end:shr-trait impl Shr for u128 { - fn shr(self, other: u8) -> u128 { + fn shr(self, other: u128) -> u128 { self >> other } } impl Shr for u64 { - fn shr(self, other: u8) -> u64 { + fn shr(self, other: u64) -> u64 { self >> other } } impl Shr for u32 { - fn shr(self, other: u8) -> u32 { + fn shr(self, other: u32) -> u32 { self >> other } } impl Shr for u16 { - fn shr(self, other: u8) -> u16 { + fn shr(self, other: u16) -> u16 { self >> other } } @@ -346,28 +346,28 @@ impl Shr for u8 { } } impl Shr for u1 { - fn shr(self, other: u8) -> u1 { + fn shr(self, other: u1) -> u1 { self >> other } } impl Shr for i8 { - fn shr(self, other: u8) -> i8 { + fn shr(self, other: i8) -> i8 { self >> other } } impl Shr for i16 { - fn shr(self, other: u8) -> i16 { + fn shr(self, other: i16) -> i16 { self >> other } } impl Shr for i32 { - fn shr(self, other: u8) -> i32 { + fn shr(self, other: i32) -> i32 { self >> other } } impl Shr for i64 { - fn shr(self, other: u8) -> i64 { + fn shr(self, other: i64) -> i64 { self >> other } } diff --git a/test_programs/compile_success_no_bug/comptime_right_shift_no_overflow/Nargo.toml b/test_programs/compile_failure/comptime_right_shift_overflow/Nargo.toml similarity index 56% rename from test_programs/compile_success_no_bug/comptime_right_shift_no_overflow/Nargo.toml rename to test_programs/compile_failure/comptime_right_shift_overflow/Nargo.toml index 9ca0fd26f05..25abeebfe2d 100644 --- a/test_programs/compile_success_no_bug/comptime_right_shift_no_overflow/Nargo.toml +++ b/test_programs/compile_failure/comptime_right_shift_overflow/Nargo.toml @@ -1,5 +1,5 @@ [package] -name = "comptime_right_shift_no_overflow" +name = "comptime_right_shift_overflow" type = "bin" authors = [""] diff --git a/test_programs/compile_success_no_bug/comptime_right_shift_no_overflow/src/main.nr b/test_programs/compile_failure/comptime_right_shift_overflow/src/main.nr similarity index 100% rename from test_programs/compile_success_no_bug/comptime_right_shift_no_overflow/src/main.nr rename to test_programs/compile_failure/comptime_right_shift_overflow/src/main.nr diff --git a/test_programs/compile_success_empty/brillig_integer_binary_operations/src/main.nr b/test_programs/compile_success_empty/brillig_integer_binary_operations/src/main.nr index 2c02582c14d..33c0e08fe84 100644 --- a/test_programs/compile_success_empty/brillig_integer_binary_operations/src/main.nr +++ b/test_programs/compile_success_empty/brillig_integer_binary_operations/src/main.nr @@ -25,8 +25,8 @@ fn main() { assert((x | y) == or(x, y)); // TODO SSA => ACIR has some issues with xor ops assert(check_xor(x, y, 4)); - assert((x >> y as u8) == shr(x, y as u8)); - assert((x << y as u8) == shl(x, y as u8)); + assert((x >> y) == shr(x, y)); + assert((x << y) == shl(x, y)); } } @@ -70,10 +70,10 @@ unconstrained fn check_xor(x: u32, y: u32, result: u32) -> bool { (x ^ y) == result } -unconstrained fn shr(x: u32, y: u8) -> u32 { +unconstrained fn shr(x: u32, y: u32) -> u32 { x >> y } -unconstrained fn shl(x: u32, y: u8) -> u32 { +unconstrained fn shl(x: u32, y: u32) -> u32 { x << y } diff --git a/test_programs/compile_success_empty/cast_and_shift_global/src/main.nr b/test_programs/compile_success_empty/cast_and_shift_global/src/main.nr index 2c0158fc71a..2475df7a96e 100644 --- a/test_programs/compile_success_empty/cast_and_shift_global/src/main.nr +++ b/test_programs/compile_success_empty/cast_and_shift_global/src/main.nr @@ -1,5 +1,5 @@ global THREE: u32 = 3; -global EIGHT: u32 = 1 << THREE as u8; +global EIGHT: u32 = 1 << THREE; global SEVEN: u32 = EIGHT - 1; fn main() { diff --git a/test_programs/compile_success_empty/regression_5823/src/main.nr b/test_programs/compile_success_empty/regression_5823/src/main.nr index 1d3eb0cfa8b..f025694303a 100644 --- a/test_programs/compile_success_empty/regression_5823/src/main.nr +++ b/test_programs/compile_success_empty/regression_5823/src/main.nr @@ -1,5 +1,5 @@ fn main() { let x = 1_u64; - let y = 2_u8; + let y = 2_u64; assert_eq(x << y, 4); } diff --git a/test_programs/compile_success_empty/regression_bignum/src/main.nr b/test_programs/compile_success_empty/regression_bignum/src/main.nr index 98ec435f020..715debb52cd 100644 --- a/test_programs/compile_success_empty/regression_bignum/src/main.nr +++ b/test_programs/compile_success_empty/regression_bignum/src/main.nr @@ -41,7 +41,7 @@ unconstrained fn get_msb(val: [u64; 6]) -> u32 { unconstrained fn shl(shift: u32) -> [u64; 6] { let num_shifted_limbs = shift / 60; - let limb_shift = (shift % 60) as u8; + let limb_shift = (shift % 60) as u64; let mut result = [0; 6]; result[num_shifted_limbs] = (1 << limb_shift); diff --git a/test_programs/compile_success_with_bug/regression_8274/src/main.nr b/test_programs/compile_success_with_bug/regression_8274/src/main.nr index eb7b0be13ef..18c41ab7626 100644 --- a/test_programs/compile_success_with_bug/regression_8274/src/main.nr +++ b/test_programs/compile_success_with_bug/regression_8274/src/main.nr @@ -1,3 +1,3 @@ fn main(a: u8, b: u8) { - let h = (((a as u64) >> b) % (11912905567223247326 * 14329851068374824036)); + let h = (((a as u64) >> (b as u64)) % (11912905567223247326 * 14329851068374824036)); } diff --git a/test_programs/execution_failure/comptime_bitshift_failure/Nargo.toml b/test_programs/execution_failure/comptime_bitshift_failure/Nargo.toml new file mode 100644 index 00000000000..17c73aad7f4 --- /dev/null +++ b/test_programs/execution_failure/comptime_bitshift_failure/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "comptime_bitshift_failure" +type = "bin" +authors = [""] + +[dependencies] diff --git a/test_programs/execution_failure/comptime_bitshift_failure/src/main.nr b/test_programs/execution_failure/comptime_bitshift_failure/src/main.nr new file mode 100644 index 00000000000..d9da6d053c7 --- /dev/null +++ b/test_programs/execution_failure/comptime_bitshift_failure/src/main.nr @@ -0,0 +1,12 @@ +unconstrained fn main() { + comptime { + func_1(false) + } +} + +unconstrained fn func_1(terminate: bool) { + if !terminate { + let _ = -8_i8 >> -8_i8; + func_1(true) + } +} diff --git a/test_programs/execution_failure/regression_bitshift_normalization/Nargo.toml b/test_programs/execution_failure/regression_bitshift_normalization/Nargo.toml new file mode 100644 index 00000000000..d48c945af7d --- /dev/null +++ b/test_programs/execution_failure/regression_bitshift_normalization/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "regression_bitshift_normalization" +type = "bin" +authors = [""] + +[dependencies] diff --git a/test_programs/execution_failure/regression_bitshift_normalization/src/main.nr b/test_programs/execution_failure/regression_bitshift_normalization/src/main.nr new file mode 100644 index 00000000000..9d5655bfdb8 --- /dev/null +++ b/test_programs/execution_failure/regression_bitshift_normalization/src/main.nr @@ -0,0 +1,7 @@ +fn main() { + for idx_c in 98_u8..100_u8 { + for idx_d in 0_u8..2_u8 { + if ((1_u8 >> idx_c) == idx_d) {} else {}; + } + } +} diff --git a/test_programs/execution_success/binary_operator_overloading/src/main.nr b/test_programs/execution_success/binary_operator_overloading/src/main.nr index 03a4e1ed22f..3102dd9ce45 100644 --- a/test_programs/execution_success/binary_operator_overloading/src/main.nr +++ b/test_programs/execution_success/binary_operator_overloading/src/main.nr @@ -20,8 +20,8 @@ fn main(x: u32, y: u32) { assert((wx | wy).inner == (ex | ey)); assert((wx ^ wy).inner == (ex ^ ey)); - assert((wy << x as u8).inner == (ey << ex as u8)); - assert((wy >> x as u8).inner == (ey >> ex as u8)); + assert((wy << wx).inner == (ey << ex)); + assert((wy >> wx).inner == (ey >> ex)); assert((wx == wy) == (ex == ey)); assert((wx < wy) == (ex < ey)); @@ -103,14 +103,14 @@ impl BitXor for Wrapper { } impl Shl for Wrapper { - fn shl(self, other: u8) -> Self { - Wrapper::new(self.inner << other) + fn shl(self, other: Self) -> Self { + Wrapper::new(self.inner << other.inner) } } impl Shr for Wrapper { - fn shr(self, other: u8) -> Self { - Wrapper::new(self.inner >> other) + fn shr(self, other: Self) -> Self { + Wrapper::new(self.inner >> other.inner) } } diff --git a/test_programs/execution_success/bit_shifts_comptime/src/main.nr b/test_programs/execution_success/bit_shifts_comptime/src/main.nr index 5788cff43d4..747ff6a2245 100644 --- a/test_programs/execution_success/bit_shifts_comptime/src/main.nr +++ b/test_programs/execution_success/bit_shifts_comptime/src/main.nr @@ -23,20 +23,17 @@ fn main(x: u64) { regression_8310(); //regression 8791 - assert(-(x as i64) >> 63 == -1); - assert(a >> 27 == -1); + assert(-(x as i64) >> 62 == -1); + assert(a >> 14 == -1); } fn regression_2250() { - let a: u1 = 1 >> 1; - assert(a == 0); - - let b: u32 = 1 >> 32; + let b: u32 = 1 >> 31; assert(b == 0); } fn regression_8310() { let x: i64 = -356710612598522715; - let b = x >> 64; + let b = x >> 62; assert(b == -1); } diff --git a/test_programs/execution_success/bit_shifts_runtime/src/main.nr b/test_programs/execution_success/bit_shifts_runtime/src/main.nr index 31767994d9f..a0ccea79c56 100644 --- a/test_programs/execution_success/bit_shifts_runtime/src/main.nr +++ b/test_programs/execution_success/bit_shifts_runtime/src/main.nr @@ -1,4 +1,4 @@ -fn main(x: u64, y: u8, z: i16, u: i64) { +fn main(x: u64, y: u64, z: i16, u: i64) { // runtime shifts on compile-time known values assert(64 << y == 128); assert(64 >> y == 32); @@ -6,23 +6,24 @@ fn main(x: u64, y: u8, z: i16, u: i64) { assert(x << y == 128); assert(x >> y == 32); // regression tests for issue #8176, superseded by issue #8791 - assert(u >> (x as u8) == -1); - assert(z >> (x as u8) == -1); + assert(u >> (x as i64 - 2) == -1); // Bit-shift with signed integers let mut a: i8 = y as i8; let mut b: i8 = x as i8; assert(b << 1 == -128); assert(b >> 2 == 16); - assert(b >> y == 32); + assert(b >> a == 32); a = -a; - assert(a << 7 == -128); - assert(a << y == -2); + assert(a << 6 == -64); + assert(a << -a == -2); - assert(x >> (x as u8) == 0); + assert(x >> (x - 1) == 0); assert_eq(z >> 3, -97); - assert(z >> 16 == -1); - assert(-z >> x as u8 == 0); + assert(z >> 14 == -1); + let rhs = (if x as i16 > 14 { 14 } else { x as i16 }); + assert(z >> rhs == -1); + assert(-z >> rhs == 0); } diff --git a/test_programs/execution_success/inactive_signed_bitshift/Nargo.toml b/test_programs/execution_success/inactive_signed_bitshift/Nargo.toml new file mode 100644 index 00000000000..3a0bcb16786 --- /dev/null +++ b/test_programs/execution_success/inactive_signed_bitshift/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "inactive_signed_bitshift" +type = "bin" +authors = [""] + +[dependencies] diff --git a/test_programs/execution_success/inactive_signed_bitshift/Prover.toml b/test_programs/execution_success/inactive_signed_bitshift/Prover.toml new file mode 100644 index 00000000000..b544a91137e --- /dev/null +++ b/test_programs/execution_success/inactive_signed_bitshift/Prover.toml @@ -0,0 +1,3 @@ +active = false +a = "-0x000000000000000000000000000000000000000000000000000000000000005f" +return = 0 diff --git a/test_programs/execution_success/inactive_signed_bitshift/src/main.nr b/test_programs/execution_success/inactive_signed_bitshift/src/main.nr new file mode 100644 index 00000000000..3e013a9c44e --- /dev/null +++ b/test_programs/execution_success/inactive_signed_bitshift/src/main.nr @@ -0,0 +1,7 @@ +fn main(active: bool, a: pub i16) -> pub i16 { + if active { + (a >> a) + } else { + 0 + } +} diff --git a/test_programs/execution_success/regression_1144_1169_2399_6609/src/main.nr b/test_programs/execution_success/regression_1144_1169_2399_6609/src/main.nr index 809fdbe4b28..240bd73333e 100644 --- a/test_programs/execution_success/regression_1144_1169_2399_6609/src/main.nr +++ b/test_programs/execution_success/regression_1144_1169_2399_6609/src/main.nr @@ -87,7 +87,7 @@ fn bitshift_literal_4() -> u64 { bits } -fn bitshift_variable(idx: u8) -> u64 { +fn bitshift_variable(idx: u64) -> u64 { let mut bits: u64 = 0; bits |= 1 << idx; diff --git a/test_programs/execution_success/shift_right_overflow/src/main.nr b/test_programs/execution_success/shift_right_overflow/src/main.nr index c5d23ab5cd9..7872fd7c4ba 100644 --- a/test_programs/execution_success/shift_right_overflow/src/main.nr +++ b/test_programs/execution_success/shift_right_overflow/src/main.nr @@ -1,5 +1,5 @@ fn main(x: u8) { - // This would previously overflow in ACIR. Now it returns zero. - let value = 1 >> x; + // 1>>8 and 1>>9 would previously return zero, now they overflow. + let value = 1 >> 7; assert_eq(value, 0); } diff --git a/test_programs/execution_success/signed_bitshift/Nargo.toml b/test_programs/execution_success/signed_bitshift/Nargo.toml new file mode 100644 index 00000000000..3ef8084c95d --- /dev/null +++ b/test_programs/execution_success/signed_bitshift/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "signed_bitshift" +type = "bin" +authors = [""] + +[dependencies] diff --git a/test_programs/execution_success/signed_bitshift/src/main.nr b/test_programs/execution_success/signed_bitshift/src/main.nr new file mode 100644 index 00000000000..11c5fac8c85 --- /dev/null +++ b/test_programs/execution_success/signed_bitshift/src/main.nr @@ -0,0 +1,10 @@ +fn main() { + for idx_d in 0..1 { + if idx_d == 2 { + // previously the LICM pass would hoist this bitshift out of the loop (and so out from under the predicate) + // such that it would fail execution. + let a = (345422577_i32 >> -115035501_i32); + let _ = 1 >> a; + } + } +} diff --git a/test_programs/execution_success/u128_type/src/main.nr b/test_programs/execution_success/u128_type/src/main.nr index acfa3d28eec..0b436422d7e 100644 --- a/test_programs/execution_success/u128_type/src/main.nr +++ b/test_programs/execution_success/u128_type/src/main.nr @@ -1,4 +1,4 @@ -fn main(x: u128, y: u128, z: u8) { +fn main(x: u128, y: u128, z: u128) { let const_x = 12345; let const_y = 2345678; let const_z = 2; diff --git a/test_programs/execution_success/u16_support/src/main.nr b/test_programs/execution_success/u16_support/src/main.nr index ceaf45a3fc6..4c2dd530a6d 100644 --- a/test_programs/execution_success/u16_support/src/main.nr +++ b/test_programs/execution_success/u16_support/src/main.nr @@ -19,9 +19,9 @@ fn test_u16(x: u16) { assert(t4 == t1); let mut small_int = x as u16; - let shift = small_int << (x as u8); + let shift = small_int << x; assert(shift == 8); - assert(shift >> (x as u8) == small_int); + assert(shift >> x == small_int); assert(shift >> 15 == 0); assert(shift << 15 == 0); } diff --git a/test_programs/noir_test_success/bit_shifts/Nargo.toml b/test_programs/noir_test_success/bit_shifts/Nargo.toml new file mode 100644 index 00000000000..07355cd7790 --- /dev/null +++ b/test_programs/noir_test_success/bit_shifts/Nargo.toml @@ -0,0 +1,5 @@ +[package] +name = "bit_shifts" +type = "bin" +authors = [""] +[dependencies] diff --git a/test_programs/noir_test_success/bit_shifts/src/main.nr b/test_programs/noir_test_success/bit_shifts/src/main.nr new file mode 100644 index 00000000000..888d223e192 --- /dev/null +++ b/test_programs/noir_test_success/bit_shifts/src/main.nr @@ -0,0 +1,119 @@ +unconstrained fn u_shift(a: u128, b: u128) -> Field { + shift(a, b) +} + +fn shift(a: u128, b: u128) -> Field { + let mut c = 0; + + let rhs = if (b > 127) { 127 } else { b }; + c += (a << rhs) as Field; + c += (a >> rhs) as Field; + c += (a << 127) as Field; + c += (a >> 127) as Field; + + let a = a as u64; + let b = b as u64; + let rhs = if (b > 63) { 63 } else { b }; + c += (a << rhs) as Field; + c += (a >> rhs) as Field; + c += (a << 63) as Field; + c += (a >> 63) as Field; + + let a = a as u32; + let b = b as u32; + let rhs = if (b > 31) { 31 } else { b }; + c += (a << rhs) as Field; + c += (a >> rhs) as Field; + c += (a << 31) as Field; + c += (a >> 31) as Field; + + let a = a as u16; + let b = b as u16; + let rhs = if (b > 15) { 15 } else { b }; + c += (a << rhs) as Field; + c += (a >> rhs) as Field; + c += (a << 15) as Field; + c += (a >> 15) as Field; + + let a = a as u8; + let b = b as u8; + let rhs = if (b > 7) { 7 } else { b }; + c += (a << rhs) as Field; + c += (a >> rhs) as Field; + c += (a << 7) as Field; + c += (a >> 7) as Field; + + let a = a as i64; + let b = b as i64; + let b = if b <= 0 { 1 } else { b }; + let rhs = if (b > 62) { 62 } else { b }; + c += (a << rhs) as u64 as Field; + c += (a >> rhs) as u64 as Field; + c += (a << 62) as u64 as Field; + c += (a >> 62) as u64 as Field; + + let a = a as i32; + let b = b as i32; + let b = if b <= 0 { 1 } else { b }; + let rhs = if (b > 30) { 30 } else { b }; + c += (a << rhs) as u64 as Field; + c += (a >> rhs) as u64 as Field; + c += (a << 30) as u64 as Field; + c += (a >> 30) as u64 as Field; + + let a = a as i16; + let b = b as i16; + let b = if b <= 0 { 1 } else { b }; + let rhs = if (b > 14) { 14 } else { b }; + c += (a << rhs) as u64 as Field; + c += (a >> rhs) as u64 as Field; + c += (a << 14) as u64 as Field; + c += (a >> 14) as u64 as Field; + + let a = a as i8; + let b = b as i8; + let b = if b <= 0 { 1 } else { b }; + let rhs = if (b > 6) { 6 } else { b }; + c += (a << rhs) as u64 as Field; + c += (a >> rhs) as u64 as Field; + c += (a << 6) as u64 as Field; + c += (a >> 6) as u64 as Field; + c +} + +#[test] +fn test_bit_shifts00() { + let a = unsafe { u_shift(4, 5) }; + assert_eq(shift(4, 5), a); + let a = unsafe { u_shift(0, 132) }; + assert_eq(shift(0, 132), a); + let a = unsafe { u_shift(234234, 42) }; + assert_eq(shift(234234, 42), a); + let a = unsafe { u_shift(2434, 11) }; + assert_eq(shift(2434, 11), a); +} + +#[test(should_fail)] +fn test_bit_shifts_overflow1() -> i8 { + 2_i8 >> 7 +} + +#[test(should_fail)] +fn test_bit_shifts_overflow2() -> u8 { + 2_u8 >> 8 +} + +#[test(should_fail)] +fn test_bit_shifts_overflow3() -> i32 { + 2_i32 >> 31 +} + +#[test(should_fail)] +fn test_bit_shifts_overflow4() -> u32 { + 2_u32 >> 32 +} + +#[test(should_fail)] +fn test_bit_shifts_overflow5() -> i32 { + 2_i32 >> -1 +} diff --git a/test_programs/noir_test_success/comptime_blackbox/src/main.nr b/test_programs/noir_test_success/comptime_blackbox/src/main.nr index 8ac361a52a0..8ae42cb0bf6 100644 --- a/test_programs/noir_test_success/comptime_blackbox/src/main.nr +++ b/test_programs/noir_test_success/comptime_blackbox/src/main.nr @@ -6,7 +6,7 @@ fn test_bitshift() { let c = comptime { let a: i32 = 10; let b: u32 = 4; - a << b as u8 + a << b as i32 }; assert_eq(c, 160); } diff --git a/tooling/ast_fuzzer/fuzz/src/targets/orig_vs_morph.rs b/tooling/ast_fuzzer/fuzz/src/targets/orig_vs_morph.rs index e357531c506..59be42e5e6f 100644 --- a/tooling/ast_fuzzer/fuzz/src/targets/orig_vs_morph.rs +++ b/tooling/ast_fuzzer/fuzz/src/targets/orig_vs_morph.rs @@ -738,14 +738,10 @@ mod helpers { // Choose a type for the LHS and RHS. let lhs_type = u.choose_iter(type_options)?; - let rhs_type = match op { - BinaryOp::ShiftLeft | BinaryOp::ShiftRight => &types::U8, - _ => lhs_type, - }; // Generate expressions for LHS and RHS. let lhs_expr = gen_expr(u, lhs_type, max_depth.saturating_sub(1))?; - let rhs_expr = gen_expr(u, rhs_type, max_depth.saturating_sub(1))?; + let rhs_expr = gen_expr(u, lhs_type, max_depth.saturating_sub(1))?; let mut expr = expr::binary(lhs_expr, op, rhs_expr); diff --git a/tooling/ast_fuzzer/src/compare/compiled.rs b/tooling/ast_fuzzer/src/compare/compiled.rs index 448bbbc048d..809539a592c 100644 --- a/tooling/ast_fuzzer/src/compare/compiled.rs +++ b/tooling/ast_fuzzer/src/compare/compiled.rs @@ -45,27 +45,34 @@ pub struct NargoErrorWithTypes(NargoError, SsaErrorTypes); impl NargoErrorWithTypes { /// Copy of `NargoError::user_defined_failure_message` accepting `SsaErrorTypes` instead of ABI errors. fn user_defined_failure_message(&self) -> Option { - match &self.0 { - NargoError::ExecutionError(error) => match error { - ExecutionError::AssertionFailed(payload, _, _) => match payload { - ResolvedAssertionPayload::String(message) => Some(message.to_string()), - ResolvedAssertionPayload::Raw(raw) => { - let ssa_type = self.1.get(&raw.selector)?; - match ssa_type { - ErrorType::String(message) => Some(message.to_string()), - ErrorType::Dynamic(_hir_type) => { - // This would be the case if we have a format string that needs to be filled with the raw payload - // decoded as ABI type. The code generator shouldn't produce this kind. It shouldn't be too difficult - // to map the type, but the mapper in `crate::abi` doesn't handle format strings at the moment. - panic!("didn't expect dynamic error types") - } + let unwrap_payload = |payload: &ResolvedAssertionPayload| { + match payload { + ResolvedAssertionPayload::String(message) => Some(message.to_string()), + ResolvedAssertionPayload::Raw(raw) => { + let ssa_type = self.1.get(&raw.selector)?; + match ssa_type { + ErrorType::String(message) => Some(message.to_string()), + ErrorType::Dynamic(_hir_type) => { + // This would be the case if we have a format string that needs to be filled with the raw payload + // decoded as ABI type. The code generator shouldn't produce this kind. It shouldn't be too difficult + // to map the type, but the mapper in `crate::abi` doesn't handle format strings at the moment. + panic!("didn't expect dynamic error types") } } - }, + } + } + }; + + match &self.0 { + NargoError::ExecutionError(error) => match error { + ExecutionError::AssertionFailed(payload, _, _) => unwrap_payload(payload), ExecutionError::SolvingError(error, _) => match error { OpcodeResolutionError::BlackBoxFunctionFailed(_, reason) => { Some(reason.to_string()) } + OpcodeResolutionError::BrilligFunctionFailed { + payload: Some(payload), .. + } => unwrap_payload(payload), _ => None, }, }, @@ -152,6 +159,9 @@ impl Comparable for NargoErrorWithTypes { || msg.contains("divisor of zero") || msg.contains("division by zero") }) + || both(&msg1, &msg2, |msg| { + msg.contains("attempted to shift by") || msg.contains("bit-shift with overflow") + }) } else { false }; @@ -329,3 +339,48 @@ impl HasPrograms for CompareMorph { vec![&self.program.0, &self.program.1] } } + +#[cfg(test)] +mod test { + use std::collections::BTreeMap; + + use acir::circuit::{ErrorSelector, brillig::BrilligFunctionId}; + use acvm::pwg::{RawAssertionPayload, ResolvedAssertionPayload}; + use nargo::errors::ExecutionError; + + use super::{ErrorType, NargoErrorWithTypes}; + use crate::compare::Comparable; + + #[test] + fn matches_brillig_bitshift_error_with_acir_error() { + let error = NargoErrorWithTypes( + nargo::NargoError::ExecutionError(ExecutionError::AssertionFailed( + ResolvedAssertionPayload::Raw(RawAssertionPayload { + selector: ErrorSelector::new(14514982005979867414), + data: vec![], + }), + Vec::new(), + Some(BrilligFunctionId(0)), + )), + BTreeMap::from_iter([( + ErrorSelector::new(14514982005979867414), + ErrorType::String("attempt to bit-shift with overflow".to_string()), + )]), + ); + let brillig_error = NargoErrorWithTypes( + nargo::NargoError::ExecutionError(ExecutionError::AssertionFailed( + ResolvedAssertionPayload::String( + "Attempted to shift by 4294958994 bits on a type of bit size 8".to_string(), + ), + Vec::new(), + Some(BrilligFunctionId(0)), + )), + BTreeMap::from_iter([( + ErrorSelector::new(14514982005979867414), + ErrorType::String("attempt to bit-shift with overflow".to_string()), + )]), + ); + + assert!(NargoErrorWithTypes::equivalent(&error, &brillig_error)); + } +} diff --git a/tooling/ast_fuzzer/src/compare/interpreted.rs b/tooling/ast_fuzzer/src/compare/interpreted.rs index 60c67378ea9..0e49a95bd63 100644 --- a/tooling/ast_fuzzer/src/compare/interpreted.rs +++ b/tooling/ast_fuzzer/src/compare/interpreted.rs @@ -194,6 +194,7 @@ impl Comparable for ssa::interpreter::errors::InterpreterError { BinaryOp::Add { unchecked: false } => msg == "attempt to add with overflow", BinaryOp::Sub { unchecked: false } => msg == "attempt to subtract with overflow", BinaryOp::Mul { unchecked: false } => msg == "attempt to multiply with overflow", + BinaryOp::Shl | BinaryOp::Shr => msg == "attempt to bit-shift with overflow", _ => false, }, ( diff --git a/tooling/ast_fuzzer/src/program/func.rs b/tooling/ast_fuzzer/src/program/func.rs index e6404aed7d8..cc72ea495a5 100644 --- a/tooling/ast_fuzzer/src/program/func.rs +++ b/tooling/ast_fuzzer/src/program/func.rs @@ -996,16 +996,12 @@ impl<'a> FunctionContext<'a> { // Choose a type for the LHS and RHS. let lhs_type = u.choose_iter(lhs_opts)?.clone(); - let rhs_type = match op { - BinaryOp::ShiftLeft | BinaryOp::ShiftRight => &types::U8, - _ => &lhs_type, - }; // Generate expressions for LHS and RHS. let (lhs_expr, lhs_dyn) = self.gen_expr(u, &lhs_type, max_depth.saturating_sub(1), Flags::NESTED)?; let (rhs_expr, rhs_dyn) = - self.gen_expr(u, rhs_type, max_depth.saturating_sub(1), Flags::NESTED)?; + self.gen_expr(u, &lhs_type, max_depth.saturating_sub(1), Flags::NESTED)?; let mut expr = expr::binary(lhs_expr, op, rhs_expr); diff --git a/tooling/ast_fuzzer/src/program/types.rs b/tooling/ast_fuzzer/src/program/types.rs index cc4abad8a17..d75ed79414a 100644 --- a/tooling/ast_fuzzer/src/program/types.rs +++ b/tooling/ast_fuzzer/src/program/types.rs @@ -307,7 +307,7 @@ pub fn can_binary_op_return(op: &BinaryOp, typ: &Type) -> bool { /// These are operations that commonly fail with random constants. pub fn can_binary_op_overflow(op: &BinaryOp) -> bool { use BinaryOpKind::*; - matches!(op, Add | Subtract | Multiply | ShiftLeft) + matches!(op, Add | Subtract | Multiply | ShiftLeft | ShiftRight) } /// Can the binary operation fail because the RHS is zero. diff --git a/tooling/nargo_cli/tests/snapshots/compile_failure/comptime_right_shift_overflow/execute__tests__stderr.snap b/tooling/nargo_cli/tests/snapshots/compile_failure/comptime_right_shift_overflow/execute__tests__stderr.snap new file mode 100644 index 00000000000..34470c6646b --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/compile_failure/comptime_right_shift_overflow/execute__tests__stderr.snap @@ -0,0 +1,12 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: stderr +--- +error: Attempt to bit-shift with overflow + ┌─ src/main.nr:2:24 + │ +2 │ let y = comptime { 1 >> 32 }; + │ ------- + │ + +Aborting due to 1 previous error diff --git a/tooling/nargo_cli/tests/snapshots/compile_success_empty/brillig_integer_binary_operations/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/compile_success_empty/brillig_integer_binary_operations/execute__tests__expanded.snap index f47a5d9f7bd..2cc572ac851 100644 --- a/tooling/nargo_cli/tests/snapshots/compile_success_empty/brillig_integer_binary_operations/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/compile_success_empty/brillig_integer_binary_operations/execute__tests__expanded.snap @@ -19,8 +19,8 @@ fn main() { assert((x & y) == and(x, y)); assert((x | y) == or(x, y)); assert(check_xor(x, y, 4_u32)); - assert((x >> (y as u8)) == shr(x, y as u8)); - assert((x << (y as u8)) == shl(x, y as u8)); + assert((x >> y) == shr(x, y)); + assert((x << y) == shl(x, y)); } } @@ -64,10 +64,10 @@ unconstrained fn check_xor(x: u32, y: u32, result: u32) -> bool { (x ^ y) == result } -unconstrained fn shr(x: u32, y: u8) -> u32 { +unconstrained fn shr(x: u32, y: u32) -> u32 { x >> y } -unconstrained fn shl(x: u32, y: u8) -> u32 { +unconstrained fn shl(x: u32, y: u32) -> u32 { x << y } diff --git a/tooling/nargo_cli/tests/snapshots/compile_success_empty/brillig_integer_binary_operations/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/compile_success_empty/brillig_integer_binary_operations/execute__tests__force_brillig_false_inliner_0.snap index 8e567e44329..52f2e9aab0c 100644 --- a/tooling/nargo_cli/tests/snapshots/compile_success_empty/brillig_integer_binary_operations/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/compile_success_empty/brillig_integer_binary_operations/execute__tests__force_brillig_false_inliner_0.snap @@ -17,7 +17,7 @@ expression: artifact "public parameters indices : []", "return value indices : []" ], - "debug_symbols": "ndTdasMgFAfwd/E6F35H+ypjBJOYIogJVgsj9N1nQ7TdYDDOlR6P/x96oTua7ZivgwvLekOXjx2N0XnvroNfJ5PcGsrq/uhQLYcUrS1L6K1fUpuJNiR0Cdn7Dt2Nz8em22bCMSYTSxd3yIa5jAVcnLfP2aN7pfHfUcX1GVaCt7j4d15jdeY1YZC87Gu+p4A8wVSeAMGMQARCWBUIUTCBNoFqkKBeZ1AggfImUA66BcPtFgz3IEHiJkgBEThvAucwgekmCAkRBG6CIKAzCKma0P98VZ+lMpOLv/+Bu4nOjN6e5ZLD9NZNX1vt1H9ki+tk5xztUzp6xf4G", + "debug_symbols": "ndTLqsMgEAbgd3GdhddW+yqHQzCJKYKYYLVQQt+9NkTTFgplVjqO/4duZkGD6dK5tX6cLuj0t6AuWOfsuXVTr6OdfD5d7g0qZRuDMfkIvfRzatbB+IhOPjnXoKt2ab10mbVf16hD7uIGGT/kNYOjdea5uzd7Gn+PSiq2sGR7XPyel7zkpQLkFWdbXnEJyBOM6Qbk7REkSFUFxWGCLALBAiIQUd9ADiCBkipQCvoFPdZfUMkgAmOHIjBOIAInVeAUKIgqMAoS5P4GBRIEr4IQ78J/rnRvw+ccuOpgdefMVo7J9y/deJtLp8yROUy9GVIwT2ntZfsB", "file_map": {}, "names": [ "main" diff --git a/tooling/nargo_cli/tests/snapshots/compile_success_empty/regression_5823/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/compile_success_empty/regression_5823/execute__tests__expanded.snap index b3a0785c418..4d48b03e97e 100644 --- a/tooling/nargo_cli/tests/snapshots/compile_success_empty/regression_5823/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/compile_success_empty/regression_5823/execute__tests__expanded.snap @@ -4,6 +4,6 @@ expression: expanded_code --- fn main() { let x: u64 = 1_u64; - let y: u8 = 2_u8; + let y: u64 = 2_u64; assert((x << y) == 4_u64); } diff --git a/tooling/nargo_cli/tests/snapshots/compile_success_empty/regression_bignum/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/compile_success_empty/regression_bignum/execute__tests__expanded.snap index 402d02b2d35..fe9857e0e87 100644 --- a/tooling/nargo_cli/tests/snapshots/compile_success_empty/regression_bignum/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/compile_success_empty/regression_bignum/execute__tests__expanded.snap @@ -48,7 +48,7 @@ unconstrained fn get_msb(val: [u64; 6]) -> u32 { unconstrained fn shl(shift: u32) -> [u64; 6] { let num_shifted_limbs: u32 = shift / 60_u32; - let limb_shift: u8 = (shift % 60_u32) as u8; + let limb_shift: u64 = (shift % 60_u32) as u64; let mut result: [u64; 6] = [0_u64; 6]; result[num_shifted_limbs] = 1_u64 << limb_shift; for i in 1_u32..6_u32 - num_shifted_limbs { diff --git a/tooling/nargo_cli/tests/snapshots/compile_success_empty/regression_bignum/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/compile_success_empty/regression_bignum/execute__tests__force_brillig_false_inliner_0.snap index efbbc6b9b14..2bf9844dd64 100644 --- a/tooling/nargo_cli/tests/snapshots/compile_success_empty/regression_bignum/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/compile_success_empty/regression_bignum/execute__tests__force_brillig_false_inliner_0.snap @@ -17,7 +17,7 @@ expression: artifact "public parameters indices : []", "return value indices : []" ], - "debug_symbols": "pZXLjsIgFED/hXUXvC/1VyYTgxUNCaENtiYT478PmoKOCV3cWVG4PYfH5XEjR3dYznsfT+OF7L5u5JB8CP68D+NgZz/G3Hq7d6RU93NyLjeRt3imJptcnMkuLiF05GrD8vzpMtn4LGebcpR2xMVjLrPw5IN7fN27F03bqAS9wrI3FVd/edbmjZErb4xC8D0VK99TieE5FF4YFF/7Fz2GV5VXqP4NX3lGKW0JNhKoRFkApXSLN22eMa7KCJhQKIPqq0H3OIOpBkDNglNWDJxylEG+DLiV5KzmkgtAGQCqoX0ctwyCVYMQOIOssxBS4MZAX2PoEXta67KhNGDOBNREABMYXpRLEdp53OJl2c6gGYbX5VIF4BgeypEGY/7X/wf/nWt28OnzGbva5O0huLV6WuLwFp1/phIpz+CUxsEdl+Qepmcsu38B", + "debug_symbols": "pZXNjsIgEIDfhXMP/A/4KpuNwYqGhNAGW5ON8d0XTaGuST3MnihMvw86TOFGjv4wn/chnYYL2X3dyCGHGMN5H4feTWFIZfR270jt7qfsfRkiL/FCjS77NJFdmmPsyNXF+fnSZXTp2U4ulyjtiE/H0hbhKUT/eLp3K023UQl6gaU1DVd/ebbNGyMX3hiF4C0VC2+pxPAcKi8Mim/zC4vhVeMVan7DF55RSrcEHzZQiZoApfQWb7Z5xriqK2BCoQzKNoO2OINpBgCMgdOWR04FyiBXg8KtgYlm2C7GjwZoeeAWlUnBmkEInEG2rxBS4tbAVgOmprWuBaUBwwOrWwlMYHhRD0UQgOFl3QTQDMPreqgCcAwP9ZcGY/43/xv/XXquD/n9Gru6HNwh+qV7mlP/Ep1+xhqp1+CYh94f5+wfpmesuH8B", "file_map": {}, "names": [ "main" diff --git a/tooling/nargo_cli/tests/snapshots/compile_success_no_bug/comptime_right_shift_no_overflow/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/compile_success_no_bug/comptime_right_shift_no_overflow/execute__tests__expanded.snap deleted file mode 100644 index 94a84bdd154..00000000000 --- a/tooling/nargo_cli/tests/snapshots/compile_success_no_bug/comptime_right_shift_no_overflow/execute__tests__expanded.snap +++ /dev/null @@ -1,8 +0,0 @@ ---- -source: tooling/nargo_cli/tests/execute.rs -expression: expanded_code ---- -fn main(x: Field) -> pub Field { - let y: u32 = 0_u32; - x + (y as Field) -} diff --git a/tooling/nargo_cli/tests/snapshots/compile_success_with_bug/regression_8274/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/compile_success_with_bug/regression_8274/execute__tests__expanded.snap index 36226f82c57..d2b11e45c46 100644 --- a/tooling/nargo_cli/tests/snapshots/compile_success_with_bug/regression_8274/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/compile_success_with_bug/regression_8274/execute__tests__expanded.snap @@ -3,5 +3,5 @@ source: tooling/nargo_cli/tests/execute.rs expression: expanded_code --- fn main(a: u8, b: u8) { - let h: u64 = ((a as u64) >> b) % (11912905567223247326_u64 * 14329851068374824036_u64); + let h: u64 = ((a as u64) >> (b as u64)) % (11912905567223247326_u64 * 14329851068374824036_u64); } diff --git a/tooling/nargo_cli/tests/snapshots/compile_success_with_bug/regression_8274/execute__tests__stderr.snap b/tooling/nargo_cli/tests/snapshots/compile_success_with_bug/regression_8274/execute__tests__stderr.snap index fbde323cb9d..210610267c4 100644 --- a/tooling/nargo_cli/tests/snapshots/compile_success_with_bug/regression_8274/execute__tests__stderr.snap +++ b/tooling/nargo_cli/tests/snapshots/compile_success_with_bug/regression_8274/execute__tests__stderr.snap @@ -5,15 +5,15 @@ expression: stderr warning: unused variable h ┌─ src/main.nr:2:9 │ -2 │ let h = (((a as u64) >> b) % (11912905567223247326 * 14329851068374824036)); +2 │ let h = (((a as u64) >> (b as u64)) % (11912905567223247326 * 14329851068374824036)); │ - unused variable │ bug: Assertion is always false: attempt to multiply with overflow - ┌─ src/main.nr:2:35 + ┌─ src/main.nr:2:44 │ -2 │ let h = (((a as u64) >> b) % (11912905567223247326 * 14329851068374824036)); - │ ------------------------------------------- As a result, the compiled circuit is ensured to fail. Other assertions may also fail during execution +2 │ let h = (((a as u64) >> (b as u64)) % (11912905567223247326 * 14329851068374824036)); + │ ------------------------------------------- As a result, the compiled circuit is ensured to fail. Other assertions may also fail during execution │ = Call stack: - 1. src/main.nr:2:35 + 1. src/main.nr:2:44 diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__expanded.snap index 562d7125174..9223cab2d9b 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__expanded.snap @@ -26,7 +26,7 @@ fn compute_root(leaf: [u8; 32], path: [u8; 64], _index: u32, root: [u8; 32]) { } } current = std::hash::blake3(hash_input); - index = index >> 1_u8; + index = index >> 1_u32; } assert(root == current); } diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 62048992834..de6d5f854a9 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -84,9 +84,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [[EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ], EXPR [ (1, _2) 0 ], EXPR [ (1, _3) 0 ], EXPR [ (1, _4) 0 ], EXPR [ (1, _5) 0 ], EXPR [ (1, _6) 0 ], EXPR [ (1, _7) 0 ], EXPR [ (1, _8) 0 ], EXPR [ (1, _9) 0 ], EXPR [ (1, _10) 0 ], EXPR [ (1, _11) 0 ], EXPR [ (1, _12) 0 ], EXPR [ (1, _13) 0 ], EXPR [ (1, _14) 0 ], EXPR [ (1, _15) 0 ], EXPR [ (1, _16) 0 ], EXPR [ (1, _17) 0 ], EXPR [ (1, _18) 0 ], EXPR [ (1, _19) 0 ], EXPR [ (1, _20) 0 ], EXPR [ (1, _21) 0 ], EXPR [ (1, _22) 0 ], EXPR [ (1, _23) 0 ], EXPR [ (1, _24) 0 ], EXPR [ (1, _25) 0 ], EXPR [ (1, _26) 0 ], EXPR [ (1, _27) 0 ], EXPR [ (1, _28) 0 ], EXPR [ (1, _29) 0 ], EXPR [ (1, _30) 0 ], EXPR [ (1, _31) 0 ]], [EXPR [ (1, _32) 0 ], EXPR [ (1, _33) 0 ], EXPR [ (1, _34) 0 ], EXPR [ (1, _35) 0 ], EXPR [ (1, _36) 0 ], EXPR [ (1, _37) 0 ], EXPR [ (1, _38) 0 ], EXPR [ (1, _39) 0 ], EXPR [ (1, _40) 0 ], EXPR [ (1, _41) 0 ], EXPR [ (1, _42) 0 ], EXPR [ (1, _43) 0 ], EXPR [ (1, _44) 0 ], EXPR [ (1, _45) 0 ], EXPR [ (1, _46) 0 ], EXPR [ (1, _47) 0 ], EXPR [ (1, _48) 0 ], EXPR [ (1, _49) 0 ], EXPR [ (1, _50) 0 ], EXPR [ (1, _51) 0 ], EXPR [ (1, _52) 0 ], EXPR [ (1, _53) 0 ], EXPR [ (1, _54) 0 ], EXPR [ (1, _55) 0 ], EXPR [ (1, _56) 0 ], EXPR [ (1, _57) 0 ], EXPR [ (1, _58) 0 ], EXPR [ (1, _59) 0 ], EXPR [ (1, _60) 0 ], EXPR [ (1, _61) 0 ], EXPR [ (1, _62) 0 ], EXPR [ (1, _63) 0 ], EXPR [ (1, _64) 0 ], EXPR [ (1, _65) 0 ], EXPR [ (1, _66) 0 ], EXPR [ (1, _67) 0 ], EXPR [ (1, _68) 0 ], EXPR [ (1, _69) 0 ], EXPR [ (1, _70) 0 ], EXPR [ (1, _71) 0 ], EXPR [ (1, _72) 0 ], EXPR [ (1, _73) 0 ], EXPR [ (1, _74) 0 ], EXPR [ (1, _75) 0 ], EXPR [ (1, _76) 0 ], EXPR [ (1, _77) 0 ], EXPR [ (1, _78) 0 ], EXPR [ (1, _79) 0 ], EXPR [ (1, _80) 0 ], EXPR [ (1, _81) 0 ], EXPR [ (1, _82) 0 ], EXPR [ (1, _83) 0 ], EXPR [ (1, _84) 0 ], EXPR [ (1, _85) 0 ], EXPR [ (1, _86) 0 ], EXPR [ (1, _87) 0 ], EXPR [ (1, _88) 0 ], EXPR [ (1, _89) 0 ], EXPR [ (1, _90) 0 ], EXPR [ (1, _91) 0 ], EXPR [ (1, _92) 0 ], EXPR [ (1, _93) 0 ], EXPR [ (1, _94) 0 ], EXPR [ (1, _95) 0 ]], EXPR [ (1, _96) 0 ], [EXPR [ (1, _97) 0 ], EXPR [ (1, _98) 0 ], EXPR [ (1, _99) 0 ], EXPR [ (1, _100) 0 ], EXPR [ (1, _101) 0 ], EXPR [ (1, _102) 0 ], EXPR [ (1, _103) 0 ], EXPR [ (1, _104) 0 ], EXPR [ (1, _105) 0 ], EXPR [ (1, _106) 0 ], EXPR [ (1, _107) 0 ], EXPR [ (1, _108) 0 ], EXPR [ (1, _109) 0 ], EXPR [ (1, _110) 0 ], EXPR [ (1, _111) 0 ], EXPR [ (1, _112) 0 ], EXPR [ (1, _113) 0 ], EXPR [ (1, _114) 0 ], EXPR [ (1, _115) 0 ], EXPR [ (1, _116) 0 ], EXPR [ (1, _117) 0 ], EXPR [ (1, _118) 0 ], EXPR [ (1, _119) 0 ], EXPR [ (1, _120) 0 ], EXPR [ (1, _121) 0 ], EXPR [ (1, _122) 0 ], EXPR [ (1, _123) 0 ], EXPR [ (1, _124) 0 ], EXPR [ (1, _125) 0 ], EXPR [ (1, _126) 0 ], EXPR [ (1, _127) 0 ], EXPR [ (1, _128) 0 ]]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32968 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 129 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U8) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U8) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Cast { destination: Direct(32881), source: Direct(32881), bit_size: Integer(U8) }, Cast { destination: Direct(32882), source: Direct(32882), bit_size: Integer(U8) }, Cast { destination: Direct(32883), source: Direct(32883), bit_size: Integer(U8) }, Cast { destination: Direct(32884), source: Direct(32884), bit_size: Integer(U8) }, Cast { destination: Direct(32885), source: Direct(32885), bit_size: Integer(U8) }, Cast { destination: Direct(32886), source: Direct(32886), bit_size: Integer(U8) }, Cast { destination: Direct(32887), source: Direct(32887), bit_size: Integer(U8) }, Cast { destination: Direct(32888), source: Direct(32888), bit_size: Integer(U8) }, Cast { destination: Direct(32889), source: Direct(32889), bit_size: Integer(U8) }, Cast { destination: Direct(32890), source: Direct(32890), bit_size: Integer(U8) }, Cast { destination: Direct(32891), source: Direct(32891), bit_size: Integer(U8) }, Cast { destination: Direct(32892), source: Direct(32892), bit_size: Integer(U8) }, Cast { destination: Direct(32893), source: Direct(32893), bit_size: Integer(U8) }, Cast { destination: Direct(32894), source: Direct(32894), bit_size: Integer(U8) }, Cast { destination: Direct(32895), source: Direct(32895), bit_size: Integer(U8) }, Cast { destination: Direct(32896), source: Direct(32896), bit_size: Integer(U8) }, Cast { destination: Direct(32897), source: Direct(32897), bit_size: Integer(U8) }, Cast { destination: Direct(32898), source: Direct(32898), bit_size: Integer(U8) }, Cast { destination: Direct(32899), source: Direct(32899), bit_size: Integer(U8) }, Cast { destination: Direct(32900), source: Direct(32900), bit_size: Integer(U8) }, Cast { destination: Direct(32901), source: Direct(32901), bit_size: Integer(U8) }, Cast { destination: Direct(32902), source: Direct(32902), bit_size: Integer(U8) }, Cast { destination: Direct(32903), source: Direct(32903), bit_size: Integer(U8) }, Cast { destination: Direct(32904), source: Direct(32904), bit_size: Integer(U8) }, Cast { destination: Direct(32905), source: Direct(32905), bit_size: Integer(U8) }, Cast { destination: Direct(32906), source: Direct(32906), bit_size: Integer(U8) }, Cast { destination: Direct(32907), source: Direct(32907), bit_size: Integer(U8) }, Cast { destination: Direct(32908), source: Direct(32908), bit_size: Integer(U8) }, Cast { destination: Direct(32909), source: Direct(32909), bit_size: Integer(U8) }, Cast { destination: Direct(32910), source: Direct(32910), bit_size: Integer(U8) }, Cast { destination: Direct(32911), source: Direct(32911), bit_size: Integer(U8) }, Cast { destination: Direct(32912), source: Direct(32912), bit_size: Integer(U8) }, Cast { destination: Direct(32913), source: Direct(32913), bit_size: Integer(U8) }, Cast { destination: Direct(32914), source: Direct(32914), bit_size: Integer(U8) }, Cast { destination: Direct(32915), source: Direct(32915), bit_size: Integer(U8) }, Cast { destination: Direct(32916), source: Direct(32916), bit_size: Integer(U8) }, Cast { destination: Direct(32917), source: Direct(32917), bit_size: Integer(U8) }, Cast { destination: Direct(32918), source: Direct(32918), bit_size: Integer(U8) }, Cast { destination: Direct(32919), source: Direct(32919), bit_size: Integer(U8) }, Cast { destination: Direct(32920), source: Direct(32920), bit_size: Integer(U8) }, Cast { destination: Direct(32921), source: Direct(32921), bit_size: Integer(U8) }, Cast { destination: Direct(32922), source: Direct(32922), bit_size: Integer(U8) }, Cast { destination: Direct(32923), source: Direct(32923), bit_size: Integer(U8) }, Cast { destination: Direct(32924), source: Direct(32924), bit_size: Integer(U8) }, Cast { destination: Direct(32925), source: Direct(32925), bit_size: Integer(U8) }, Cast { destination: Direct(32926), source: Direct(32926), bit_size: Integer(U8) }, Cast { destination: Direct(32927), source: Direct(32927), bit_size: Integer(U8) }, Cast { destination: Direct(32928), source: Direct(32928), bit_size: Integer(U8) }, Cast { destination: Direct(32929), source: Direct(32929), bit_size: Integer(U8) }, Cast { destination: Direct(32930), source: Direct(32930), bit_size: Integer(U8) }, Cast { destination: Direct(32931), source: Direct(32931), bit_size: Integer(U8) }, Cast { destination: Direct(32932), source: Direct(32932), bit_size: Integer(U8) }, Cast { destination: Direct(32933), source: Direct(32933), bit_size: Integer(U8) }, Cast { destination: Direct(32934), source: Direct(32934), bit_size: Integer(U8) }, Cast { destination: Direct(32935), source: Direct(32935), bit_size: Integer(U32) }, Cast { destination: Direct(32936), source: Direct(32936), bit_size: Integer(U8) }, Cast { destination: Direct(32937), source: Direct(32937), bit_size: Integer(U8) }, Cast { destination: Direct(32938), source: Direct(32938), bit_size: Integer(U8) }, Cast { destination: Direct(32939), source: Direct(32939), bit_size: Integer(U8) }, Cast { destination: Direct(32940), source: Direct(32940), bit_size: Integer(U8) }, Cast { destination: Direct(32941), source: Direct(32941), bit_size: Integer(U8) }, Cast { destination: Direct(32942), source: Direct(32942), bit_size: Integer(U8) }, Cast { destination: Direct(32943), source: Direct(32943), bit_size: Integer(U8) }, Cast { destination: Direct(32944), source: Direct(32944), bit_size: Integer(U8) }, Cast { destination: Direct(32945), source: Direct(32945), bit_size: Integer(U8) }, Cast { destination: Direct(32946), source: Direct(32946), bit_size: Integer(U8) }, Cast { destination: Direct(32947), source: Direct(32947), bit_size: Integer(U8) }, Cast { destination: Direct(32948), source: Direct(32948), bit_size: Integer(U8) }, Cast { destination: Direct(32949), source: Direct(32949), bit_size: Integer(U8) }, Cast { destination: Direct(32950), source: Direct(32950), bit_size: Integer(U8) }, Cast { destination: Direct(32951), source: Direct(32951), bit_size: Integer(U8) }, Cast { destination: Direct(32952), source: Direct(32952), bit_size: Integer(U8) }, Cast { destination: Direct(32953), source: Direct(32953), bit_size: Integer(U8) }, Cast { destination: Direct(32954), source: Direct(32954), bit_size: Integer(U8) }, Cast { destination: Direct(32955), source: Direct(32955), bit_size: Integer(U8) }, Cast { destination: Direct(32956), source: Direct(32956), bit_size: Integer(U8) }, Cast { destination: Direct(32957), source: Direct(32957), bit_size: Integer(U8) }, Cast { destination: Direct(32958), source: Direct(32958), bit_size: Integer(U8) }, Cast { destination: Direct(32959), source: Direct(32959), bit_size: Integer(U8) }, Cast { destination: Direct(32960), source: Direct(32960), bit_size: Integer(U8) }, Cast { destination: Direct(32961), source: Direct(32961), bit_size: Integer(U8) }, Cast { destination: Direct(32962), source: Direct(32962), bit_size: Integer(U8) }, Cast { destination: Direct(32963), source: Direct(32963), bit_size: Integer(U8) }, Cast { destination: Direct(32964), source: Direct(32964), bit_size: Integer(U8) }, Cast { destination: Direct(32965), source: Direct(32965), bit_size: Integer(U8) }, Cast { destination: Direct(32966), source: Direct(32966), bit_size: Integer(U8) }, Cast { destination: Direct(32967), source: Direct(32967), bit_size: Integer(U8) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(1), source: Relative(5) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32871 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(2), source: Relative(5) }, Mov { destination: Relative(3), source: Direct(32935) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32936 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 188 }, Call { location: 193 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32968 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 187 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 180 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 32 }, Return, Call { location: 204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(1) }, Mov { destination: Relative(8), source: Relative(2) }, Mov { destination: Relative(9), source: Relative(3) }, Mov { destination: Relative(10), source: Relative(4) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 210 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 209 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 204 }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Mov { destination: Relative(10), source: Relative(8) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 232 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 226 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 64 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 1 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 237 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, JumpIf { condition: Relative(10), location: 253 }, Jump { location: 240 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(4) }, Mov { destination: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 342 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(6) }, JumpIf { condition: Relative(2), location: 252 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(1) } }, Return, Load { destination: Relative(11), source_pointer: Relative(7) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 259 }, Call { location: 366 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(11) }, Mov { destination: Relative(11), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(7) }, BinaryIntOp { destination: Relative(13), op: Mul, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Load { destination: Relative(14), source_pointer: Relative(1) }, Cast { destination: Relative(16), source: Relative(14), bit_size: Integer(U1) }, Cast { destination: Relative(15), source: Relative(16), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Direct(32835) }, Not { destination: Relative(15), source: Relative(14), bit_size: U1 }, Cast { destination: Relative(16), source: Relative(14), bit_size: Integer(U32) }, Cast { destination: Relative(14), source: Relative(15), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(14), op: Mul, bit_size: U32, lhs: Relative(16), rhs: Direct(32838) }, Mov { destination: Relative(10), source: Direct(32835) }, Jump { location: 276 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Direct(32838) }, JumpIf { condition: Relative(12), location: 295 }, Jump { location: 279 }, Load { destination: Relative(10), source_pointer: Relative(11) }, Mov { destination: Relative(11), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(11), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 64 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(12), size: Relative(13) }, output: HeapArray { pointer: Relative(14), size: 32 } }), Store { destination_pointer: Relative(6), source: Relative(11) }, Load { destination: Relative(10), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(11), op: Shr, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Store { destination_pointer: Relative(1), source: Relative(11) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(10) }, Jump { location: 237 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(16), location: 299 }, Call { location: 369 }, Load { destination: Relative(16), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(10) }, Load { destination: Relative(17), source_pointer: Relative(19) }, Load { destination: Relative(16), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, JumpIf { condition: Relative(18), location: 307 }, Call { location: 372 }, Mov { destination: Direct(32771), source: Relative(16) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 65 }, Call { location: 375 }, Mov { destination: Relative(18), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(12) }, Store { destination_pointer: Relative(20), source: Relative(17) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(14) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(16), location: 318 }, Call { location: 369 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 322 }, Call { location: 369 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, JumpIf { condition: Relative(17), location: 325 }, Call { location: 372 }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(16) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, JumpIf { condition: Relative(16), location: 331 }, Call { location: 372 }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 65 }, Call { location: 375 }, Mov { destination: Relative(16), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(12) }, Store { destination_pointer: Relative(20), source: Relative(17) }, Store { destination_pointer: Relative(11), source: Relative(16) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(32837) }, Mov { destination: Relative(10), source: Relative(12) }, Jump { location: 276 }, Call { location: 204 }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Direct(32836) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 348 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, JumpIf { condition: Relative(5), location: 353 }, Jump { location: 351 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(5), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(8) }, Store { destination_pointer: Relative(4), source: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 348 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 379 }, Jump { location: 381 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 396 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 393 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 386 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 396 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32968 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 129 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U8) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U8) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Cast { destination: Direct(32881), source: Direct(32881), bit_size: Integer(U8) }, Cast { destination: Direct(32882), source: Direct(32882), bit_size: Integer(U8) }, Cast { destination: Direct(32883), source: Direct(32883), bit_size: Integer(U8) }, Cast { destination: Direct(32884), source: Direct(32884), bit_size: Integer(U8) }, Cast { destination: Direct(32885), source: Direct(32885), bit_size: Integer(U8) }, Cast { destination: Direct(32886), source: Direct(32886), bit_size: Integer(U8) }, Cast { destination: Direct(32887), source: Direct(32887), bit_size: Integer(U8) }, Cast { destination: Direct(32888), source: Direct(32888), bit_size: Integer(U8) }, Cast { destination: Direct(32889), source: Direct(32889), bit_size: Integer(U8) }, Cast { destination: Direct(32890), source: Direct(32890), bit_size: Integer(U8) }, Cast { destination: Direct(32891), source: Direct(32891), bit_size: Integer(U8) }, Cast { destination: Direct(32892), source: Direct(32892), bit_size: Integer(U8) }, Cast { destination: Direct(32893), source: Direct(32893), bit_size: Integer(U8) }, Cast { destination: Direct(32894), source: Direct(32894), bit_size: Integer(U8) }, Cast { destination: Direct(32895), source: Direct(32895), bit_size: Integer(U8) }, Cast { destination: Direct(32896), source: Direct(32896), bit_size: Integer(U8) }, Cast { destination: Direct(32897), source: Direct(32897), bit_size: Integer(U8) }, Cast { destination: Direct(32898), source: Direct(32898), bit_size: Integer(U8) }, Cast { destination: Direct(32899), source: Direct(32899), bit_size: Integer(U8) }, Cast { destination: Direct(32900), source: Direct(32900), bit_size: Integer(U8) }, Cast { destination: Direct(32901), source: Direct(32901), bit_size: Integer(U8) }, Cast { destination: Direct(32902), source: Direct(32902), bit_size: Integer(U8) }, Cast { destination: Direct(32903), source: Direct(32903), bit_size: Integer(U8) }, Cast { destination: Direct(32904), source: Direct(32904), bit_size: Integer(U8) }, Cast { destination: Direct(32905), source: Direct(32905), bit_size: Integer(U8) }, Cast { destination: Direct(32906), source: Direct(32906), bit_size: Integer(U8) }, Cast { destination: Direct(32907), source: Direct(32907), bit_size: Integer(U8) }, Cast { destination: Direct(32908), source: Direct(32908), bit_size: Integer(U8) }, Cast { destination: Direct(32909), source: Direct(32909), bit_size: Integer(U8) }, Cast { destination: Direct(32910), source: Direct(32910), bit_size: Integer(U8) }, Cast { destination: Direct(32911), source: Direct(32911), bit_size: Integer(U8) }, Cast { destination: Direct(32912), source: Direct(32912), bit_size: Integer(U8) }, Cast { destination: Direct(32913), source: Direct(32913), bit_size: Integer(U8) }, Cast { destination: Direct(32914), source: Direct(32914), bit_size: Integer(U8) }, Cast { destination: Direct(32915), source: Direct(32915), bit_size: Integer(U8) }, Cast { destination: Direct(32916), source: Direct(32916), bit_size: Integer(U8) }, Cast { destination: Direct(32917), source: Direct(32917), bit_size: Integer(U8) }, Cast { destination: Direct(32918), source: Direct(32918), bit_size: Integer(U8) }, Cast { destination: Direct(32919), source: Direct(32919), bit_size: Integer(U8) }, Cast { destination: Direct(32920), source: Direct(32920), bit_size: Integer(U8) }, Cast { destination: Direct(32921), source: Direct(32921), bit_size: Integer(U8) }, Cast { destination: Direct(32922), source: Direct(32922), bit_size: Integer(U8) }, Cast { destination: Direct(32923), source: Direct(32923), bit_size: Integer(U8) }, Cast { destination: Direct(32924), source: Direct(32924), bit_size: Integer(U8) }, Cast { destination: Direct(32925), source: Direct(32925), bit_size: Integer(U8) }, Cast { destination: Direct(32926), source: Direct(32926), bit_size: Integer(U8) }, Cast { destination: Direct(32927), source: Direct(32927), bit_size: Integer(U8) }, Cast { destination: Direct(32928), source: Direct(32928), bit_size: Integer(U8) }, Cast { destination: Direct(32929), source: Direct(32929), bit_size: Integer(U8) }, Cast { destination: Direct(32930), source: Direct(32930), bit_size: Integer(U8) }, Cast { destination: Direct(32931), source: Direct(32931), bit_size: Integer(U8) }, Cast { destination: Direct(32932), source: Direct(32932), bit_size: Integer(U8) }, Cast { destination: Direct(32933), source: Direct(32933), bit_size: Integer(U8) }, Cast { destination: Direct(32934), source: Direct(32934), bit_size: Integer(U8) }, Cast { destination: Direct(32935), source: Direct(32935), bit_size: Integer(U32) }, Cast { destination: Direct(32936), source: Direct(32936), bit_size: Integer(U8) }, Cast { destination: Direct(32937), source: Direct(32937), bit_size: Integer(U8) }, Cast { destination: Direct(32938), source: Direct(32938), bit_size: Integer(U8) }, Cast { destination: Direct(32939), source: Direct(32939), bit_size: Integer(U8) }, Cast { destination: Direct(32940), source: Direct(32940), bit_size: Integer(U8) }, Cast { destination: Direct(32941), source: Direct(32941), bit_size: Integer(U8) }, Cast { destination: Direct(32942), source: Direct(32942), bit_size: Integer(U8) }, Cast { destination: Direct(32943), source: Direct(32943), bit_size: Integer(U8) }, Cast { destination: Direct(32944), source: Direct(32944), bit_size: Integer(U8) }, Cast { destination: Direct(32945), source: Direct(32945), bit_size: Integer(U8) }, Cast { destination: Direct(32946), source: Direct(32946), bit_size: Integer(U8) }, Cast { destination: Direct(32947), source: Direct(32947), bit_size: Integer(U8) }, Cast { destination: Direct(32948), source: Direct(32948), bit_size: Integer(U8) }, Cast { destination: Direct(32949), source: Direct(32949), bit_size: Integer(U8) }, Cast { destination: Direct(32950), source: Direct(32950), bit_size: Integer(U8) }, Cast { destination: Direct(32951), source: Direct(32951), bit_size: Integer(U8) }, Cast { destination: Direct(32952), source: Direct(32952), bit_size: Integer(U8) }, Cast { destination: Direct(32953), source: Direct(32953), bit_size: Integer(U8) }, Cast { destination: Direct(32954), source: Direct(32954), bit_size: Integer(U8) }, Cast { destination: Direct(32955), source: Direct(32955), bit_size: Integer(U8) }, Cast { destination: Direct(32956), source: Direct(32956), bit_size: Integer(U8) }, Cast { destination: Direct(32957), source: Direct(32957), bit_size: Integer(U8) }, Cast { destination: Direct(32958), source: Direct(32958), bit_size: Integer(U8) }, Cast { destination: Direct(32959), source: Direct(32959), bit_size: Integer(U8) }, Cast { destination: Direct(32960), source: Direct(32960), bit_size: Integer(U8) }, Cast { destination: Direct(32961), source: Direct(32961), bit_size: Integer(U8) }, Cast { destination: Direct(32962), source: Direct(32962), bit_size: Integer(U8) }, Cast { destination: Direct(32963), source: Direct(32963), bit_size: Integer(U8) }, Cast { destination: Direct(32964), source: Direct(32964), bit_size: Integer(U8) }, Cast { destination: Direct(32965), source: Direct(32965), bit_size: Integer(U8) }, Cast { destination: Direct(32966), source: Direct(32966), bit_size: Integer(U8) }, Cast { destination: Direct(32967), source: Direct(32967), bit_size: Integer(U8) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(1), source: Relative(5) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32871 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(2), source: Relative(5) }, Mov { destination: Relative(3), source: Direct(32935) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32936 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 188 }, Call { location: 193 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32968 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 187 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 180 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 32 }, Return, Call { location: 204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(1) }, Mov { destination: Relative(8), source: Relative(2) }, Mov { destination: Relative(9), source: Relative(3) }, Mov { destination: Relative(10), source: Relative(4) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 210 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 209 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 204 }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Mov { destination: Relative(10), source: Relative(8) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 232 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 226 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 236 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, JumpIf { condition: Relative(9), location: 252 }, Jump { location: 239 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(4) }, Mov { destination: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 341 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(6) }, JumpIf { condition: Relative(2), location: 251 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(1) } }, Return, Load { destination: Relative(10), source_pointer: Relative(7) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 258 }, Call { location: 365 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(7) }, BinaryIntOp { destination: Relative(12), op: Mul, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Load { destination: Relative(13), source_pointer: Relative(1) }, Cast { destination: Relative(15), source: Relative(13), bit_size: Integer(U1) }, Cast { destination: Relative(14), source: Relative(15), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Direct(32835) }, Not { destination: Relative(14), source: Relative(13), bit_size: U1 }, Cast { destination: Relative(15), source: Relative(13), bit_size: Integer(U32) }, Cast { destination: Relative(13), source: Relative(14), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(14), op: Mul, bit_size: U32, lhs: Relative(13), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(13), op: Mul, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, Mov { destination: Relative(9), source: Direct(32835) }, Jump { location: 275 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Direct(32838) }, JumpIf { condition: Relative(11), location: 294 }, Jump { location: 278 }, Load { destination: Relative(9), source_pointer: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 64 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(11), size: Relative(12) }, output: HeapArray { pointer: Relative(13), size: 32 } }), Store { destination_pointer: Relative(6), source: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(10), op: Shr, bit_size: U32, lhs: Relative(9), rhs: Direct(32837) }, Store { destination_pointer: Relative(1), source: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(9) }, Jump { location: 236 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: LessThanEquals, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, JumpIf { condition: Relative(15), location: 298 }, Call { location: 368 }, Load { destination: Relative(15), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Load { destination: Relative(15), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(8) }, JumpIf { condition: Relative(17), location: 306 }, Call { location: 371 }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 65 }, Call { location: 374 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(11) }, Store { destination_pointer: Relative(19), source: Relative(16) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(13) }, BinaryIntOp { destination: Relative(15), op: LessThanEquals, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, JumpIf { condition: Relative(15), location: 317 }, Call { location: 368 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(9) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 321 }, Call { location: 368 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(8) }, JumpIf { condition: Relative(16), location: 324 }, Call { location: 371 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(15) }, Load { destination: Relative(16), source_pointer: Relative(19) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(8) }, JumpIf { condition: Relative(15), location: 330 }, Call { location: 371 }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 65 }, Call { location: 374 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(11) }, Store { destination_pointer: Relative(19), source: Relative(16) }, Store { destination_pointer: Relative(10), source: Relative(15) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32837) }, Mov { destination: Relative(9), source: Relative(11) }, Jump { location: 275 }, Call { location: 204 }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Direct(32836) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 347 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, JumpIf { condition: Relative(5), location: 352 }, Jump { location: 350 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(5), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(8) }, Store { destination_pointer: Relative(4), source: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 347 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 378 }, Jump { location: 380 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 395 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 392 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 385 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 395 }, Return]" ], - "debug_symbols": "pZbdbqMwEIXfhWsubI/HP32VqqrSlK6QEIlostKqyrvvDJwh3YtIlfcm5zMwhzE+OHx178Pb9dfrOH+cPrun56/ubRmnafz1Op2Oh8t4muXoV+f0x9fYPflelKEJmqEFWlcNzkE9NGzqMfY2JmiEMjRBxT+oFmjdNDiohwYoQSOUoQkKvwC/AD+CH8GP5DoSjXI8qspxVg1QgkYoQxM0Qwu0bsoOCj9Gv4x+Gf0y+mX0y+iX0W9Cvwn9Jsw/wS+JX1JlqPhl1QwVv6JaN81yvqrq+jmBoguoTsUbBAMyiAZskAyygQZDV7JUQMUjrR4aoGqiz3zN1grZoBjUDWjNV1TwBsGADKIBGyQDdWaFYlAB3hl4g2BABuqcFNggGWQDdc4KFaCZ3cAbBAMyiAbqXBSSQTYoBhWg6d3Ab8tHFAzIIBqwQTLIBsUAMSDknJBzQs5Jc+0lMKRBDnqlJnk7olH2CmyQDDTNQaEYVMAaaF2aZIZrpFfQTLvbre9sY3q9LMOg+9K3nUr2r/NhGeZL9zRfp6nvfh+m63rR5/kwr3o5LHJWLIf5XVQMP8ZpULr192r3uDRH1Hrv92r+cblkFPUS0oZ6eWtRL+9tQ33KNvdUXEN9Jpt/ji33l3ja/Cm31Cey+hya6vfnn0tDfayM+lhb+mdOqOfcsv4p2PwTP5y/7rGPDLy8XZZgymm38PXHU9hb4NDyCJlsCTi2LCH7vT60RJBT3peg6f7FHiDXli2A8x6B2nJ/+dDa96Ba493hx3uIc9U2EUe1xcDfDUJqMSB376D8bwePpqBBffgUg7cYePn0++7wIoPDcVz++Qi+qdUyHt6mAcOP63z8dvby52xn7CP6vJyOw/t1GdTp/iUtP8+UuaeaXuS/TUY+596XLCP99HgOLvbBVR16vTbVnrJ/uWlrfwE=", + "debug_symbols": "pZbNbuJAEITfxWcO89fzk1eJoogQZ4VkAXJgpVXEu2+3qTLZA1I0e6G+we5yj6cY5mt4H98uv173h4/j5/D0/DW8zftp2v96nY677Xl/POi3X4OzD9/S8OQ3qgLN0AKt0LZocA7qoeGmHmPPcYQmqEAzVP2DaYW2mwYH9dAAjdAEFWiGwi/AL8Avwi/CL+r90VSvJ9Wk18XUQwM0QhNUoBlaoBXabirwE/Qt6FvQt6BvQd+CvgV9C/rO6Duj7wy/rH7ZNEHVr5hmqPpV03rTotebqa2jM7CFNKfqCJ4QCJGQCELIBAuIrWStBLzS5qAeaib2zpeMLZAJhVAJ1p5WxSVoC3hCIERCIgjBnMWgECqhAbwjeEIgmHM2SAQhZII5F4NKaAAL7w08IRAiwZyrgRAyoRAqoQEsxrZ80XJ8g0CIhEQQQiYUAmIQkfOInEfkPFquvQYmWpCD3WlJvn1jUfYGiSAES3MwKIRKsEDb0mQaLpFewDLtrtfNwI3p9TyPo+1L33Yq3b9O23k8nIenw2WaNsPv7XRZbvo8bQ+LnrezXlXL8fCuqoYf+2k0um7u1e5xaUmo9d6v1fLjco0m6jWbHfX6a0V9yK2jPhfOPVfXUV8i519Sz/M1lZx/LD31ObK+hK769f2X2lGfmqA+tZ7+RTLqpfSsfw6cf5aH87c99pGB1x8VExxLXi18+/EU1hYk9LxCiVwCST1LKH6tDz0RlFzWJeh6fuULlNazBUhZI9B6nq8HrXUPai3dHX68hzjXuIm42HoM/N0g5B6D6O4d1P/t4NEULKgP32LwjIHXo993hxcdbHf7+Z9D8NWs5v32bRox/Lgcdt+unv+ceIWH6NN83I3vl3k0p/tJWj+eo/6PxCYv+t+mI1/KxteiIztxPAeXNsE1G3q7V/f8WNzL1Vr7Cw==", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n if result {\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use super::{Eq, max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0_u64, 1), 0);\n assert_eq(min(0_u64, 0), 0);\n assert_eq(min(1_u64, 1), 1);\n assert_eq(min(255_u8, 0), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0_u64, 1), 1);\n assert_eq(max(0_u64, 0), 0);\n assert_eq(max(1_u64, 1), 1);\n assert_eq(max(255_u8, 0), 255);\n }\n\n #[test]\n fn correctly_handles_unequal_length_slices() {\n let slice_1 = &[0, 1, 2, 3];\n let slice_2 = &[0, 1, 2];\n assert(!slice_1.eq(slice_2));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_0.snap index 128dbfa98fb..a15709d1c92 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_0.snap @@ -84,9 +84,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [[EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ], EXPR [ (1, _2) 0 ], EXPR [ (1, _3) 0 ], EXPR [ (1, _4) 0 ], EXPR [ (1, _5) 0 ], EXPR [ (1, _6) 0 ], EXPR [ (1, _7) 0 ], EXPR [ (1, _8) 0 ], EXPR [ (1, _9) 0 ], EXPR [ (1, _10) 0 ], EXPR [ (1, _11) 0 ], EXPR [ (1, _12) 0 ], EXPR [ (1, _13) 0 ], EXPR [ (1, _14) 0 ], EXPR [ (1, _15) 0 ], EXPR [ (1, _16) 0 ], EXPR [ (1, _17) 0 ], EXPR [ (1, _18) 0 ], EXPR [ (1, _19) 0 ], EXPR [ (1, _20) 0 ], EXPR [ (1, _21) 0 ], EXPR [ (1, _22) 0 ], EXPR [ (1, _23) 0 ], EXPR [ (1, _24) 0 ], EXPR [ (1, _25) 0 ], EXPR [ (1, _26) 0 ], EXPR [ (1, _27) 0 ], EXPR [ (1, _28) 0 ], EXPR [ (1, _29) 0 ], EXPR [ (1, _30) 0 ], EXPR [ (1, _31) 0 ]], [EXPR [ (1, _32) 0 ], EXPR [ (1, _33) 0 ], EXPR [ (1, _34) 0 ], EXPR [ (1, _35) 0 ], EXPR [ (1, _36) 0 ], EXPR [ (1, _37) 0 ], EXPR [ (1, _38) 0 ], EXPR [ (1, _39) 0 ], EXPR [ (1, _40) 0 ], EXPR [ (1, _41) 0 ], EXPR [ (1, _42) 0 ], EXPR [ (1, _43) 0 ], EXPR [ (1, _44) 0 ], EXPR [ (1, _45) 0 ], EXPR [ (1, _46) 0 ], EXPR [ (1, _47) 0 ], EXPR [ (1, _48) 0 ], EXPR [ (1, _49) 0 ], EXPR [ (1, _50) 0 ], EXPR [ (1, _51) 0 ], EXPR [ (1, _52) 0 ], EXPR [ (1, _53) 0 ], EXPR [ (1, _54) 0 ], EXPR [ (1, _55) 0 ], EXPR [ (1, _56) 0 ], EXPR [ (1, _57) 0 ], EXPR [ (1, _58) 0 ], EXPR [ (1, _59) 0 ], EXPR [ (1, _60) 0 ], EXPR [ (1, _61) 0 ], EXPR [ (1, _62) 0 ], EXPR [ (1, _63) 0 ], EXPR [ (1, _64) 0 ], EXPR [ (1, _65) 0 ], EXPR [ (1, _66) 0 ], EXPR [ (1, _67) 0 ], EXPR [ (1, _68) 0 ], EXPR [ (1, _69) 0 ], EXPR [ (1, _70) 0 ], EXPR [ (1, _71) 0 ], EXPR [ (1, _72) 0 ], EXPR [ (1, _73) 0 ], EXPR [ (1, _74) 0 ], EXPR [ (1, _75) 0 ], EXPR [ (1, _76) 0 ], EXPR [ (1, _77) 0 ], EXPR [ (1, _78) 0 ], EXPR [ (1, _79) 0 ], EXPR [ (1, _80) 0 ], EXPR [ (1, _81) 0 ], EXPR [ (1, _82) 0 ], EXPR [ (1, _83) 0 ], EXPR [ (1, _84) 0 ], EXPR [ (1, _85) 0 ], EXPR [ (1, _86) 0 ], EXPR [ (1, _87) 0 ], EXPR [ (1, _88) 0 ], EXPR [ (1, _89) 0 ], EXPR [ (1, _90) 0 ], EXPR [ (1, _91) 0 ], EXPR [ (1, _92) 0 ], EXPR [ (1, _93) 0 ], EXPR [ (1, _94) 0 ], EXPR [ (1, _95) 0 ]], EXPR [ (1, _96) 0 ], [EXPR [ (1, _97) 0 ], EXPR [ (1, _98) 0 ], EXPR [ (1, _99) 0 ], EXPR [ (1, _100) 0 ], EXPR [ (1, _101) 0 ], EXPR [ (1, _102) 0 ], EXPR [ (1, _103) 0 ], EXPR [ (1, _104) 0 ], EXPR [ (1, _105) 0 ], EXPR [ (1, _106) 0 ], EXPR [ (1, _107) 0 ], EXPR [ (1, _108) 0 ], EXPR [ (1, _109) 0 ], EXPR [ (1, _110) 0 ], EXPR [ (1, _111) 0 ], EXPR [ (1, _112) 0 ], EXPR [ (1, _113) 0 ], EXPR [ (1, _114) 0 ], EXPR [ (1, _115) 0 ], EXPR [ (1, _116) 0 ], EXPR [ (1, _117) 0 ], EXPR [ (1, _118) 0 ], EXPR [ (1, _119) 0 ], EXPR [ (1, _120) 0 ], EXPR [ (1, _121) 0 ], EXPR [ (1, _122) 0 ], EXPR [ (1, _123) 0 ], EXPR [ (1, _124) 0 ], EXPR [ (1, _125) 0 ], EXPR [ (1, _126) 0 ], EXPR [ (1, _127) 0 ], EXPR [ (1, _128) 0 ]]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32965 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 129 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U8) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U8) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U8) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U8) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Cast { destination: Direct(32881), source: Direct(32881), bit_size: Integer(U8) }, Cast { destination: Direct(32882), source: Direct(32882), bit_size: Integer(U8) }, Cast { destination: Direct(32883), source: Direct(32883), bit_size: Integer(U8) }, Cast { destination: Direct(32884), source: Direct(32884), bit_size: Integer(U8) }, Cast { destination: Direct(32885), source: Direct(32885), bit_size: Integer(U8) }, Cast { destination: Direct(32886), source: Direct(32886), bit_size: Integer(U8) }, Cast { destination: Direct(32887), source: Direct(32887), bit_size: Integer(U8) }, Cast { destination: Direct(32888), source: Direct(32888), bit_size: Integer(U8) }, Cast { destination: Direct(32889), source: Direct(32889), bit_size: Integer(U8) }, Cast { destination: Direct(32890), source: Direct(32890), bit_size: Integer(U8) }, Cast { destination: Direct(32891), source: Direct(32891), bit_size: Integer(U8) }, Cast { destination: Direct(32892), source: Direct(32892), bit_size: Integer(U8) }, Cast { destination: Direct(32893), source: Direct(32893), bit_size: Integer(U8) }, Cast { destination: Direct(32894), source: Direct(32894), bit_size: Integer(U8) }, Cast { destination: Direct(32895), source: Direct(32895), bit_size: Integer(U8) }, Cast { destination: Direct(32896), source: Direct(32896), bit_size: Integer(U8) }, Cast { destination: Direct(32897), source: Direct(32897), bit_size: Integer(U8) }, Cast { destination: Direct(32898), source: Direct(32898), bit_size: Integer(U8) }, Cast { destination: Direct(32899), source: Direct(32899), bit_size: Integer(U8) }, Cast { destination: Direct(32900), source: Direct(32900), bit_size: Integer(U8) }, Cast { destination: Direct(32901), source: Direct(32901), bit_size: Integer(U8) }, Cast { destination: Direct(32902), source: Direct(32902), bit_size: Integer(U8) }, Cast { destination: Direct(32903), source: Direct(32903), bit_size: Integer(U8) }, Cast { destination: Direct(32904), source: Direct(32904), bit_size: Integer(U8) }, Cast { destination: Direct(32905), source: Direct(32905), bit_size: Integer(U8) }, Cast { destination: Direct(32906), source: Direct(32906), bit_size: Integer(U8) }, Cast { destination: Direct(32907), source: Direct(32907), bit_size: Integer(U8) }, Cast { destination: Direct(32908), source: Direct(32908), bit_size: Integer(U8) }, Cast { destination: Direct(32909), source: Direct(32909), bit_size: Integer(U8) }, Cast { destination: Direct(32910), source: Direct(32910), bit_size: Integer(U8) }, Cast { destination: Direct(32911), source: Direct(32911), bit_size: Integer(U8) }, Cast { destination: Direct(32912), source: Direct(32912), bit_size: Integer(U8) }, Cast { destination: Direct(32913), source: Direct(32913), bit_size: Integer(U8) }, Cast { destination: Direct(32914), source: Direct(32914), bit_size: Integer(U8) }, Cast { destination: Direct(32915), source: Direct(32915), bit_size: Integer(U8) }, Cast { destination: Direct(32916), source: Direct(32916), bit_size: Integer(U8) }, Cast { destination: Direct(32917), source: Direct(32917), bit_size: Integer(U8) }, Cast { destination: Direct(32918), source: Direct(32918), bit_size: Integer(U8) }, Cast { destination: Direct(32919), source: Direct(32919), bit_size: Integer(U8) }, Cast { destination: Direct(32920), source: Direct(32920), bit_size: Integer(U8) }, Cast { destination: Direct(32921), source: Direct(32921), bit_size: Integer(U8) }, Cast { destination: Direct(32922), source: Direct(32922), bit_size: Integer(U8) }, Cast { destination: Direct(32923), source: Direct(32923), bit_size: Integer(U8) }, Cast { destination: Direct(32924), source: Direct(32924), bit_size: Integer(U8) }, Cast { destination: Direct(32925), source: Direct(32925), bit_size: Integer(U8) }, Cast { destination: Direct(32926), source: Direct(32926), bit_size: Integer(U8) }, Cast { destination: Direct(32927), source: Direct(32927), bit_size: Integer(U8) }, Cast { destination: Direct(32928), source: Direct(32928), bit_size: Integer(U8) }, Cast { destination: Direct(32929), source: Direct(32929), bit_size: Integer(U8) }, Cast { destination: Direct(32930), source: Direct(32930), bit_size: Integer(U8) }, Cast { destination: Direct(32931), source: Direct(32931), bit_size: Integer(U8) }, Cast { destination: Direct(32932), source: Direct(32932), bit_size: Integer(U32) }, Cast { destination: Direct(32933), source: Direct(32933), bit_size: Integer(U8) }, Cast { destination: Direct(32934), source: Direct(32934), bit_size: Integer(U8) }, Cast { destination: Direct(32935), source: Direct(32935), bit_size: Integer(U8) }, Cast { destination: Direct(32936), source: Direct(32936), bit_size: Integer(U8) }, Cast { destination: Direct(32937), source: Direct(32937), bit_size: Integer(U8) }, Cast { destination: Direct(32938), source: Direct(32938), bit_size: Integer(U8) }, Cast { destination: Direct(32939), source: Direct(32939), bit_size: Integer(U8) }, Cast { destination: Direct(32940), source: Direct(32940), bit_size: Integer(U8) }, Cast { destination: Direct(32941), source: Direct(32941), bit_size: Integer(U8) }, Cast { destination: Direct(32942), source: Direct(32942), bit_size: Integer(U8) }, Cast { destination: Direct(32943), source: Direct(32943), bit_size: Integer(U8) }, Cast { destination: Direct(32944), source: Direct(32944), bit_size: Integer(U8) }, Cast { destination: Direct(32945), source: Direct(32945), bit_size: Integer(U8) }, Cast { destination: Direct(32946), source: Direct(32946), bit_size: Integer(U8) }, Cast { destination: Direct(32947), source: Direct(32947), bit_size: Integer(U8) }, Cast { destination: Direct(32948), source: Direct(32948), bit_size: Integer(U8) }, Cast { destination: Direct(32949), source: Direct(32949), bit_size: Integer(U8) }, Cast { destination: Direct(32950), source: Direct(32950), bit_size: Integer(U8) }, Cast { destination: Direct(32951), source: Direct(32951), bit_size: Integer(U8) }, Cast { destination: Direct(32952), source: Direct(32952), bit_size: Integer(U8) }, Cast { destination: Direct(32953), source: Direct(32953), bit_size: Integer(U8) }, Cast { destination: Direct(32954), source: Direct(32954), bit_size: Integer(U8) }, Cast { destination: Direct(32955), source: Direct(32955), bit_size: Integer(U8) }, Cast { destination: Direct(32956), source: Direct(32956), bit_size: Integer(U8) }, Cast { destination: Direct(32957), source: Direct(32957), bit_size: Integer(U8) }, Cast { destination: Direct(32958), source: Direct(32958), bit_size: Integer(U8) }, Cast { destination: Direct(32959), source: Direct(32959), bit_size: Integer(U8) }, Cast { destination: Direct(32960), source: Direct(32960), bit_size: Integer(U8) }, Cast { destination: Direct(32961), source: Direct(32961), bit_size: Integer(U8) }, Cast { destination: Direct(32962), source: Direct(32962), bit_size: Integer(U8) }, Cast { destination: Direct(32963), source: Direct(32963), bit_size: Integer(U8) }, Cast { destination: Direct(32964), source: Direct(32964), bit_size: Integer(U8) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32836 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(1), source: Relative(5) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32868 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(2), source: Relative(5) }, Mov { destination: Relative(3), source: Direct(32932) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32933 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 188 }, Call { location: 189 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32965 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 187 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 180 }, Return, Return, Call { location: 339 }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Mov { destination: Relative(10), source: Relative(8) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 211 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 205 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 64 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 1 }, Mov { destination: Relative(5), source: Relative(3) }, Jump { location: 220 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(14), location: 250 }, Jump { location: 223 }, Load { destination: Relative(2), source_pointer: Relative(6) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 229 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(9) }, JumpIf { condition: Relative(3), location: 237 }, Jump { location: 232 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(1), location: 236 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Load { destination: Relative(3), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Load { destination: Relative(7), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(3), rhs: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 229 }, Load { destination: Relative(15), source_pointer: Relative(7) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(15) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 256 }, Call { location: 345 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(15) }, Mov { destination: Relative(15), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(7) }, BinaryIntOp { destination: Relative(17), op: Mul, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(1) }, Cast { destination: Relative(20), source: Relative(18), bit_size: Integer(U1) }, Cast { destination: Relative(19), source: Relative(20), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(19), rhs: Relative(3) }, Not { destination: Relative(19), source: Relative(18), bit_size: U1 }, Cast { destination: Relative(20), source: Relative(18), bit_size: Integer(U32) }, Cast { destination: Relative(18), source: Relative(19), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(19), op: Mul, bit_size: U32, lhs: Relative(18), rhs: Relative(9) }, BinaryIntOp { destination: Relative(18), op: Mul, bit_size: U32, lhs: Relative(20), rhs: Relative(9) }, Mov { destination: Relative(14), source: Relative(3) }, Jump { location: 273 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 292 }, Jump { location: 276 }, Load { destination: Relative(14), source_pointer: Relative(15) }, Mov { destination: Relative(15), source: Direct(1) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(16) }, IndirectConst { destination_pointer: Relative(15), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 64 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(16), size: Relative(17) }, output: HeapArray { pointer: Relative(18), size: 32 } }), Store { destination_pointer: Relative(6), source: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Shr, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Store { destination_pointer: Relative(1), source: Relative(15) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, Mov { destination: Relative(5), source: Relative(14) }, Jump { location: 220 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(19) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(16) }, JumpIf { condition: Relative(20), location: 296 }, Call { location: 348 }, Load { destination: Relative(20), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(14) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Load { destination: Relative(20), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, JumpIf { condition: Relative(22), location: 304 }, Call { location: 351 }, Mov { destination: Direct(32771), source: Relative(20) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 65 }, Call { location: 354 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(16) }, Store { destination_pointer: Relative(24), source: Relative(21) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(18) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(16) }, JumpIf { condition: Relative(20), location: 315 }, Call { location: 348 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(14) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(17), rhs: Relative(20) }, JumpIf { condition: Relative(21), location: 319 }, Call { location: 348 }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 322 }, Call { location: 351 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(20) }, Load { destination: Relative(21), source_pointer: Relative(24) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, JumpIf { condition: Relative(20), location: 328 }, Call { location: 351 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 65 }, Call { location: 354 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(16) }, Store { destination_pointer: Relative(24), source: Relative(21) }, Store { destination_pointer: Relative(15), source: Relative(20) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(11) }, Mov { destination: Relative(14), source: Relative(16) }, Jump { location: 273 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 344 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 358 }, Jump { location: 360 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 375 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 372 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 365 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 375 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32965 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 129 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U8) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U8) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U8) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U8) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Cast { destination: Direct(32881), source: Direct(32881), bit_size: Integer(U8) }, Cast { destination: Direct(32882), source: Direct(32882), bit_size: Integer(U8) }, Cast { destination: Direct(32883), source: Direct(32883), bit_size: Integer(U8) }, Cast { destination: Direct(32884), source: Direct(32884), bit_size: Integer(U8) }, Cast { destination: Direct(32885), source: Direct(32885), bit_size: Integer(U8) }, Cast { destination: Direct(32886), source: Direct(32886), bit_size: Integer(U8) }, Cast { destination: Direct(32887), source: Direct(32887), bit_size: Integer(U8) }, Cast { destination: Direct(32888), source: Direct(32888), bit_size: Integer(U8) }, Cast { destination: Direct(32889), source: Direct(32889), bit_size: Integer(U8) }, Cast { destination: Direct(32890), source: Direct(32890), bit_size: Integer(U8) }, Cast { destination: Direct(32891), source: Direct(32891), bit_size: Integer(U8) }, Cast { destination: Direct(32892), source: Direct(32892), bit_size: Integer(U8) }, Cast { destination: Direct(32893), source: Direct(32893), bit_size: Integer(U8) }, Cast { destination: Direct(32894), source: Direct(32894), bit_size: Integer(U8) }, Cast { destination: Direct(32895), source: Direct(32895), bit_size: Integer(U8) }, Cast { destination: Direct(32896), source: Direct(32896), bit_size: Integer(U8) }, Cast { destination: Direct(32897), source: Direct(32897), bit_size: Integer(U8) }, Cast { destination: Direct(32898), source: Direct(32898), bit_size: Integer(U8) }, Cast { destination: Direct(32899), source: Direct(32899), bit_size: Integer(U8) }, Cast { destination: Direct(32900), source: Direct(32900), bit_size: Integer(U8) }, Cast { destination: Direct(32901), source: Direct(32901), bit_size: Integer(U8) }, Cast { destination: Direct(32902), source: Direct(32902), bit_size: Integer(U8) }, Cast { destination: Direct(32903), source: Direct(32903), bit_size: Integer(U8) }, Cast { destination: Direct(32904), source: Direct(32904), bit_size: Integer(U8) }, Cast { destination: Direct(32905), source: Direct(32905), bit_size: Integer(U8) }, Cast { destination: Direct(32906), source: Direct(32906), bit_size: Integer(U8) }, Cast { destination: Direct(32907), source: Direct(32907), bit_size: Integer(U8) }, Cast { destination: Direct(32908), source: Direct(32908), bit_size: Integer(U8) }, Cast { destination: Direct(32909), source: Direct(32909), bit_size: Integer(U8) }, Cast { destination: Direct(32910), source: Direct(32910), bit_size: Integer(U8) }, Cast { destination: Direct(32911), source: Direct(32911), bit_size: Integer(U8) }, Cast { destination: Direct(32912), source: Direct(32912), bit_size: Integer(U8) }, Cast { destination: Direct(32913), source: Direct(32913), bit_size: Integer(U8) }, Cast { destination: Direct(32914), source: Direct(32914), bit_size: Integer(U8) }, Cast { destination: Direct(32915), source: Direct(32915), bit_size: Integer(U8) }, Cast { destination: Direct(32916), source: Direct(32916), bit_size: Integer(U8) }, Cast { destination: Direct(32917), source: Direct(32917), bit_size: Integer(U8) }, Cast { destination: Direct(32918), source: Direct(32918), bit_size: Integer(U8) }, Cast { destination: Direct(32919), source: Direct(32919), bit_size: Integer(U8) }, Cast { destination: Direct(32920), source: Direct(32920), bit_size: Integer(U8) }, Cast { destination: Direct(32921), source: Direct(32921), bit_size: Integer(U8) }, Cast { destination: Direct(32922), source: Direct(32922), bit_size: Integer(U8) }, Cast { destination: Direct(32923), source: Direct(32923), bit_size: Integer(U8) }, Cast { destination: Direct(32924), source: Direct(32924), bit_size: Integer(U8) }, Cast { destination: Direct(32925), source: Direct(32925), bit_size: Integer(U8) }, Cast { destination: Direct(32926), source: Direct(32926), bit_size: Integer(U8) }, Cast { destination: Direct(32927), source: Direct(32927), bit_size: Integer(U8) }, Cast { destination: Direct(32928), source: Direct(32928), bit_size: Integer(U8) }, Cast { destination: Direct(32929), source: Direct(32929), bit_size: Integer(U8) }, Cast { destination: Direct(32930), source: Direct(32930), bit_size: Integer(U8) }, Cast { destination: Direct(32931), source: Direct(32931), bit_size: Integer(U8) }, Cast { destination: Direct(32932), source: Direct(32932), bit_size: Integer(U32) }, Cast { destination: Direct(32933), source: Direct(32933), bit_size: Integer(U8) }, Cast { destination: Direct(32934), source: Direct(32934), bit_size: Integer(U8) }, Cast { destination: Direct(32935), source: Direct(32935), bit_size: Integer(U8) }, Cast { destination: Direct(32936), source: Direct(32936), bit_size: Integer(U8) }, Cast { destination: Direct(32937), source: Direct(32937), bit_size: Integer(U8) }, Cast { destination: Direct(32938), source: Direct(32938), bit_size: Integer(U8) }, Cast { destination: Direct(32939), source: Direct(32939), bit_size: Integer(U8) }, Cast { destination: Direct(32940), source: Direct(32940), bit_size: Integer(U8) }, Cast { destination: Direct(32941), source: Direct(32941), bit_size: Integer(U8) }, Cast { destination: Direct(32942), source: Direct(32942), bit_size: Integer(U8) }, Cast { destination: Direct(32943), source: Direct(32943), bit_size: Integer(U8) }, Cast { destination: Direct(32944), source: Direct(32944), bit_size: Integer(U8) }, Cast { destination: Direct(32945), source: Direct(32945), bit_size: Integer(U8) }, Cast { destination: Direct(32946), source: Direct(32946), bit_size: Integer(U8) }, Cast { destination: Direct(32947), source: Direct(32947), bit_size: Integer(U8) }, Cast { destination: Direct(32948), source: Direct(32948), bit_size: Integer(U8) }, Cast { destination: Direct(32949), source: Direct(32949), bit_size: Integer(U8) }, Cast { destination: Direct(32950), source: Direct(32950), bit_size: Integer(U8) }, Cast { destination: Direct(32951), source: Direct(32951), bit_size: Integer(U8) }, Cast { destination: Direct(32952), source: Direct(32952), bit_size: Integer(U8) }, Cast { destination: Direct(32953), source: Direct(32953), bit_size: Integer(U8) }, Cast { destination: Direct(32954), source: Direct(32954), bit_size: Integer(U8) }, Cast { destination: Direct(32955), source: Direct(32955), bit_size: Integer(U8) }, Cast { destination: Direct(32956), source: Direct(32956), bit_size: Integer(U8) }, Cast { destination: Direct(32957), source: Direct(32957), bit_size: Integer(U8) }, Cast { destination: Direct(32958), source: Direct(32958), bit_size: Integer(U8) }, Cast { destination: Direct(32959), source: Direct(32959), bit_size: Integer(U8) }, Cast { destination: Direct(32960), source: Direct(32960), bit_size: Integer(U8) }, Cast { destination: Direct(32961), source: Direct(32961), bit_size: Integer(U8) }, Cast { destination: Direct(32962), source: Direct(32962), bit_size: Integer(U8) }, Cast { destination: Direct(32963), source: Direct(32963), bit_size: Integer(U8) }, Cast { destination: Direct(32964), source: Direct(32964), bit_size: Integer(U8) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32836 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(1), source: Relative(5) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32868 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(2), source: Relative(5) }, Mov { destination: Relative(3), source: Direct(32932) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32933 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 188 }, Call { location: 189 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32965 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 187 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 180 }, Return, Return, Call { location: 338 }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Mov { destination: Relative(10), source: Relative(8) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 211 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 205 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(5), source: Relative(3) }, Jump { location: 219 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 249 }, Jump { location: 222 }, Load { destination: Relative(2), source_pointer: Relative(6) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 228 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(9) }, JumpIf { condition: Relative(3), location: 236 }, Jump { location: 231 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(1), location: 235 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Load { destination: Relative(3), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Load { destination: Relative(7), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(3), rhs: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 228 }, Load { destination: Relative(14), source_pointer: Relative(7) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(14) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 255 }, Call { location: 344 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Mov { destination: Relative(14), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(7) }, BinaryIntOp { destination: Relative(16), op: Mul, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, Load { destination: Relative(17), source_pointer: Relative(1) }, Cast { destination: Relative(19), source: Relative(17), bit_size: Integer(U1) }, Cast { destination: Relative(18), source: Relative(19), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(17), bit_size: U1 }, Cast { destination: Relative(19), source: Relative(17), bit_size: Integer(U32) }, Cast { destination: Relative(17), source: Relative(18), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(18), op: Mul, bit_size: U32, lhs: Relative(17), rhs: Relative(9) }, BinaryIntOp { destination: Relative(17), op: Mul, bit_size: U32, lhs: Relative(19), rhs: Relative(9) }, Mov { destination: Relative(13), source: Relative(3) }, Jump { location: 272 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(15), location: 291 }, Jump { location: 275 }, Load { destination: Relative(13), source_pointer: Relative(14) }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(15) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 64 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(15), size: Relative(16) }, output: HeapArray { pointer: Relative(17), size: 32 } }), Store { destination_pointer: Relative(6), source: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(14), op: Shr, bit_size: U32, lhs: Relative(13), rhs: Relative(11) }, Store { destination_pointer: Relative(1), source: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, Mov { destination: Relative(5), source: Relative(13) }, Jump { location: 219 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(18) }, BinaryIntOp { destination: Relative(19), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(19), location: 295 }, Call { location: 347 }, Load { destination: Relative(19), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(13) }, Load { destination: Relative(20), source_pointer: Relative(22) }, Load { destination: Relative(19), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 303 }, Call { location: 350 }, Mov { destination: Direct(32771), source: Relative(19) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 65 }, Call { location: 353 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(15) }, Store { destination_pointer: Relative(23), source: Relative(20) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(19), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(19), location: 314 }, Call { location: 347 }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(16), rhs: Relative(19) }, JumpIf { condition: Relative(20), location: 318 }, Call { location: 347 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(19), rhs: Relative(12) }, JumpIf { condition: Relative(20), location: 321 }, Call { location: 350 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(19) }, Load { destination: Relative(20), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, JumpIf { condition: Relative(19), location: 327 }, Call { location: 350 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 65 }, Call { location: 353 }, Mov { destination: Relative(19), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(15) }, Store { destination_pointer: Relative(23), source: Relative(20) }, Store { destination_pointer: Relative(14), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(11) }, Mov { destination: Relative(13), source: Relative(15) }, Jump { location: 272 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 343 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 357 }, Jump { location: 359 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 374 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 371 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 364 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 374 }, Return]" ], - "debug_symbols": "tZbRbqswDIbfhWsuSBzbyV5lmqauYxMSohVrj3Q09d2PDTbdLlpNOdpN/y8F/4kdE/hsXvuX8/vzML0dPpqHx8/mZR7GcXh/Hg/73Wk4TPLvZ9PpTygisRUNptEUTJMpmlLzAKpsmk3LorHrTINpNAXTZIqmZMqm2dT8gvlF0aQqPqgqPqyKpmQqcVkUZN6iKveTajJFU7b7ZL7QKRSD1DlICiEoRAdwELegy0q4TpPIlFdFWzZaGdDKgFYGtDKglQGtDGhlQCsDWhnI/EjXpHWg6KBr0opQchDPoDkSGbDeo9Vh/UfTZpknapKcHYpB7hyCQ3QAh+Sgc2nCmRx43aCcTcuqS2Np7ZbOWiA5oAM56PKiQnYoK4A22ArBITqAgzqDAjqQAztkh2KgrbaCOieF6AAOyUGdUYEc2CE7FANt3hWCgzqTAjgkB3QgB3bI6/aBdvkC0DkEh+gADskBHZY2uFzaxk+E59Pc93ogfDki5OA47uZ+OjUP03kc2+bPbjwvN30cd9Oip90sV6UR+ulVVAzfhrFXurTX6O52KCeLDSFs0fg9PPxauLSOxUvvVMRHyhYfqVTEE3vpKHc16YPnz+nm/PR78XL6bxtQSro6/NRAXhfFK9hBqTEIV4NINQbQXVeQ/3cFt1II8U4Vo57NaxUjdLcc7rQxBG9j4JrHgMDjOVbFb48R54r4VNDiU6lZPyJZPHLNY0zR8ye8nX+5s4NAvgMB+NqFofw4hW0JGGtKiOBbgKlmCzFs8bHmJEPibQuq5s9eQCw1Jzny1gLl+/xPMtrth/nbx+9FneZh9zL2Nnw7T/svV09/j37FP56P82Hfv57nXp2uX9Dy8wiYWmB8klerjAJzGzLLKCwXobSQkg6DDlNuAbuniy7tHw==", + "debug_symbols": "tZbdbqswDMffhete4DiOk73KNE2sYxMSohVrj3Q09d2PDTbdLlpNOdpN/78U/BkT+Gxe+5fz+/MwvR0+mofHz+ZlHsZxeH8eD/vuNBwm+fezafUHikjYiYJpMEXTaEqmqXlAVTbNpmXR0LamYBpM0TSakmkyZdNsav7A/IGso2gQf6Qq/lg1mpKp2GdRlPhFVe5PqmgaTZPdJ3GhVcgOxSBKaAAFcAgO4g00rRjXMJFMk6mlT5Y+WTvI2kHWDrJ2kLWDrB1k7SBrB5m/pDlpHxI4aE7akYQO4hO0xkQGrPdod1j/0bJZ4gQtktkhOxSD3DqAQ3BAB42lBWdySOsGZTbNqy4Dpr1bJmwBdIgO5KDpBQV2yA5lBdRJWwEcgoN6RoXoQA7JgR2yQzHQmQtRARyCAzqoZ1Igh+TADtmhGITWQT0nheCADtGBHJIDr9uHOuUrFANsHcAhOKBDdFjG4HLZNX4iPJ/mvtcD4csRIQfHsZv76dQ8TOdx3DV/uvG83PRx7KZFT90sV2UQ+ulVVBy+DWOvdNldrdvbphzNFgA2a/puDr9mLhNj9jIyFfYhZbMPqVTYJ/bWpdzWlI9eP8eb8dPv2cvpv21AKfHq4acO5HVRvIMtlhoHcHUQUo0DbK8Z5P/N4FYJEO50MejZvHYxYHvLw50xRvAxRq55DBK6PYcq++0x4lxhHwuZfSw1+RMlsyeueYxT8PoT3a6/3NlBTL4DgHydQig/LmFLgUJNCwl9CyjWbCHBZh9qTjJKvG1BVfzsDaRSc5ITbyNQvsd/klW3H+ZvH78X9TQP3cvY2/LtPO2/XD39PfoV/3g+zod9/3qee/V0/YKWn0ck3CHHJ3m1ygqYd5BZVrBcxLzDiLoEXUaWZXm6aGr/AA==", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n if result {\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use super::{Eq, max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0_u64, 1), 0);\n assert_eq(min(0_u64, 0), 0);\n assert_eq(min(1_u64, 1), 1);\n assert_eq(min(255_u8, 0), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0_u64, 1), 1);\n assert_eq(max(0_u64, 0), 0);\n assert_eq(max(1_u64, 1), 1);\n assert_eq(max(255_u8, 0), 255);\n }\n\n #[test]\n fn correctly_handles_unequal_length_slices() {\n let slice_1 = &[0, 1, 2, 3];\n let slice_2 = &[0, 1, 2];\n assert(!slice_1.eq(slice_2));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 128dbfa98fb..a15709d1c92 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -84,9 +84,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [[EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ], EXPR [ (1, _2) 0 ], EXPR [ (1, _3) 0 ], EXPR [ (1, _4) 0 ], EXPR [ (1, _5) 0 ], EXPR [ (1, _6) 0 ], EXPR [ (1, _7) 0 ], EXPR [ (1, _8) 0 ], EXPR [ (1, _9) 0 ], EXPR [ (1, _10) 0 ], EXPR [ (1, _11) 0 ], EXPR [ (1, _12) 0 ], EXPR [ (1, _13) 0 ], EXPR [ (1, _14) 0 ], EXPR [ (1, _15) 0 ], EXPR [ (1, _16) 0 ], EXPR [ (1, _17) 0 ], EXPR [ (1, _18) 0 ], EXPR [ (1, _19) 0 ], EXPR [ (1, _20) 0 ], EXPR [ (1, _21) 0 ], EXPR [ (1, _22) 0 ], EXPR [ (1, _23) 0 ], EXPR [ (1, _24) 0 ], EXPR [ (1, _25) 0 ], EXPR [ (1, _26) 0 ], EXPR [ (1, _27) 0 ], EXPR [ (1, _28) 0 ], EXPR [ (1, _29) 0 ], EXPR [ (1, _30) 0 ], EXPR [ (1, _31) 0 ]], [EXPR [ (1, _32) 0 ], EXPR [ (1, _33) 0 ], EXPR [ (1, _34) 0 ], EXPR [ (1, _35) 0 ], EXPR [ (1, _36) 0 ], EXPR [ (1, _37) 0 ], EXPR [ (1, _38) 0 ], EXPR [ (1, _39) 0 ], EXPR [ (1, _40) 0 ], EXPR [ (1, _41) 0 ], EXPR [ (1, _42) 0 ], EXPR [ (1, _43) 0 ], EXPR [ (1, _44) 0 ], EXPR [ (1, _45) 0 ], EXPR [ (1, _46) 0 ], EXPR [ (1, _47) 0 ], EXPR [ (1, _48) 0 ], EXPR [ (1, _49) 0 ], EXPR [ (1, _50) 0 ], EXPR [ (1, _51) 0 ], EXPR [ (1, _52) 0 ], EXPR [ (1, _53) 0 ], EXPR [ (1, _54) 0 ], EXPR [ (1, _55) 0 ], EXPR [ (1, _56) 0 ], EXPR [ (1, _57) 0 ], EXPR [ (1, _58) 0 ], EXPR [ (1, _59) 0 ], EXPR [ (1, _60) 0 ], EXPR [ (1, _61) 0 ], EXPR [ (1, _62) 0 ], EXPR [ (1, _63) 0 ], EXPR [ (1, _64) 0 ], EXPR [ (1, _65) 0 ], EXPR [ (1, _66) 0 ], EXPR [ (1, _67) 0 ], EXPR [ (1, _68) 0 ], EXPR [ (1, _69) 0 ], EXPR [ (1, _70) 0 ], EXPR [ (1, _71) 0 ], EXPR [ (1, _72) 0 ], EXPR [ (1, _73) 0 ], EXPR [ (1, _74) 0 ], EXPR [ (1, _75) 0 ], EXPR [ (1, _76) 0 ], EXPR [ (1, _77) 0 ], EXPR [ (1, _78) 0 ], EXPR [ (1, _79) 0 ], EXPR [ (1, _80) 0 ], EXPR [ (1, _81) 0 ], EXPR [ (1, _82) 0 ], EXPR [ (1, _83) 0 ], EXPR [ (1, _84) 0 ], EXPR [ (1, _85) 0 ], EXPR [ (1, _86) 0 ], EXPR [ (1, _87) 0 ], EXPR [ (1, _88) 0 ], EXPR [ (1, _89) 0 ], EXPR [ (1, _90) 0 ], EXPR [ (1, _91) 0 ], EXPR [ (1, _92) 0 ], EXPR [ (1, _93) 0 ], EXPR [ (1, _94) 0 ], EXPR [ (1, _95) 0 ]], EXPR [ (1, _96) 0 ], [EXPR [ (1, _97) 0 ], EXPR [ (1, _98) 0 ], EXPR [ (1, _99) 0 ], EXPR [ (1, _100) 0 ], EXPR [ (1, _101) 0 ], EXPR [ (1, _102) 0 ], EXPR [ (1, _103) 0 ], EXPR [ (1, _104) 0 ], EXPR [ (1, _105) 0 ], EXPR [ (1, _106) 0 ], EXPR [ (1, _107) 0 ], EXPR [ (1, _108) 0 ], EXPR [ (1, _109) 0 ], EXPR [ (1, _110) 0 ], EXPR [ (1, _111) 0 ], EXPR [ (1, _112) 0 ], EXPR [ (1, _113) 0 ], EXPR [ (1, _114) 0 ], EXPR [ (1, _115) 0 ], EXPR [ (1, _116) 0 ], EXPR [ (1, _117) 0 ], EXPR [ (1, _118) 0 ], EXPR [ (1, _119) 0 ], EXPR [ (1, _120) 0 ], EXPR [ (1, _121) 0 ], EXPR [ (1, _122) 0 ], EXPR [ (1, _123) 0 ], EXPR [ (1, _124) 0 ], EXPR [ (1, _125) 0 ], EXPR [ (1, _126) 0 ], EXPR [ (1, _127) 0 ], EXPR [ (1, _128) 0 ]]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32965 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 129 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U8) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U8) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U8) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U8) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Cast { destination: Direct(32881), source: Direct(32881), bit_size: Integer(U8) }, Cast { destination: Direct(32882), source: Direct(32882), bit_size: Integer(U8) }, Cast { destination: Direct(32883), source: Direct(32883), bit_size: Integer(U8) }, Cast { destination: Direct(32884), source: Direct(32884), bit_size: Integer(U8) }, Cast { destination: Direct(32885), source: Direct(32885), bit_size: Integer(U8) }, Cast { destination: Direct(32886), source: Direct(32886), bit_size: Integer(U8) }, Cast { destination: Direct(32887), source: Direct(32887), bit_size: Integer(U8) }, Cast { destination: Direct(32888), source: Direct(32888), bit_size: Integer(U8) }, Cast { destination: Direct(32889), source: Direct(32889), bit_size: Integer(U8) }, Cast { destination: Direct(32890), source: Direct(32890), bit_size: Integer(U8) }, Cast { destination: Direct(32891), source: Direct(32891), bit_size: Integer(U8) }, Cast { destination: Direct(32892), source: Direct(32892), bit_size: Integer(U8) }, Cast { destination: Direct(32893), source: Direct(32893), bit_size: Integer(U8) }, Cast { destination: Direct(32894), source: Direct(32894), bit_size: Integer(U8) }, Cast { destination: Direct(32895), source: Direct(32895), bit_size: Integer(U8) }, Cast { destination: Direct(32896), source: Direct(32896), bit_size: Integer(U8) }, Cast { destination: Direct(32897), source: Direct(32897), bit_size: Integer(U8) }, Cast { destination: Direct(32898), source: Direct(32898), bit_size: Integer(U8) }, Cast { destination: Direct(32899), source: Direct(32899), bit_size: Integer(U8) }, Cast { destination: Direct(32900), source: Direct(32900), bit_size: Integer(U8) }, Cast { destination: Direct(32901), source: Direct(32901), bit_size: Integer(U8) }, Cast { destination: Direct(32902), source: Direct(32902), bit_size: Integer(U8) }, Cast { destination: Direct(32903), source: Direct(32903), bit_size: Integer(U8) }, Cast { destination: Direct(32904), source: Direct(32904), bit_size: Integer(U8) }, Cast { destination: Direct(32905), source: Direct(32905), bit_size: Integer(U8) }, Cast { destination: Direct(32906), source: Direct(32906), bit_size: Integer(U8) }, Cast { destination: Direct(32907), source: Direct(32907), bit_size: Integer(U8) }, Cast { destination: Direct(32908), source: Direct(32908), bit_size: Integer(U8) }, Cast { destination: Direct(32909), source: Direct(32909), bit_size: Integer(U8) }, Cast { destination: Direct(32910), source: Direct(32910), bit_size: Integer(U8) }, Cast { destination: Direct(32911), source: Direct(32911), bit_size: Integer(U8) }, Cast { destination: Direct(32912), source: Direct(32912), bit_size: Integer(U8) }, Cast { destination: Direct(32913), source: Direct(32913), bit_size: Integer(U8) }, Cast { destination: Direct(32914), source: Direct(32914), bit_size: Integer(U8) }, Cast { destination: Direct(32915), source: Direct(32915), bit_size: Integer(U8) }, Cast { destination: Direct(32916), source: Direct(32916), bit_size: Integer(U8) }, Cast { destination: Direct(32917), source: Direct(32917), bit_size: Integer(U8) }, Cast { destination: Direct(32918), source: Direct(32918), bit_size: Integer(U8) }, Cast { destination: Direct(32919), source: Direct(32919), bit_size: Integer(U8) }, Cast { destination: Direct(32920), source: Direct(32920), bit_size: Integer(U8) }, Cast { destination: Direct(32921), source: Direct(32921), bit_size: Integer(U8) }, Cast { destination: Direct(32922), source: Direct(32922), bit_size: Integer(U8) }, Cast { destination: Direct(32923), source: Direct(32923), bit_size: Integer(U8) }, Cast { destination: Direct(32924), source: Direct(32924), bit_size: Integer(U8) }, Cast { destination: Direct(32925), source: Direct(32925), bit_size: Integer(U8) }, Cast { destination: Direct(32926), source: Direct(32926), bit_size: Integer(U8) }, Cast { destination: Direct(32927), source: Direct(32927), bit_size: Integer(U8) }, Cast { destination: Direct(32928), source: Direct(32928), bit_size: Integer(U8) }, Cast { destination: Direct(32929), source: Direct(32929), bit_size: Integer(U8) }, Cast { destination: Direct(32930), source: Direct(32930), bit_size: Integer(U8) }, Cast { destination: Direct(32931), source: Direct(32931), bit_size: Integer(U8) }, Cast { destination: Direct(32932), source: Direct(32932), bit_size: Integer(U32) }, Cast { destination: Direct(32933), source: Direct(32933), bit_size: Integer(U8) }, Cast { destination: Direct(32934), source: Direct(32934), bit_size: Integer(U8) }, Cast { destination: Direct(32935), source: Direct(32935), bit_size: Integer(U8) }, Cast { destination: Direct(32936), source: Direct(32936), bit_size: Integer(U8) }, Cast { destination: Direct(32937), source: Direct(32937), bit_size: Integer(U8) }, Cast { destination: Direct(32938), source: Direct(32938), bit_size: Integer(U8) }, Cast { destination: Direct(32939), source: Direct(32939), bit_size: Integer(U8) }, Cast { destination: Direct(32940), source: Direct(32940), bit_size: Integer(U8) }, Cast { destination: Direct(32941), source: Direct(32941), bit_size: Integer(U8) }, Cast { destination: Direct(32942), source: Direct(32942), bit_size: Integer(U8) }, Cast { destination: Direct(32943), source: Direct(32943), bit_size: Integer(U8) }, Cast { destination: Direct(32944), source: Direct(32944), bit_size: Integer(U8) }, Cast { destination: Direct(32945), source: Direct(32945), bit_size: Integer(U8) }, Cast { destination: Direct(32946), source: Direct(32946), bit_size: Integer(U8) }, Cast { destination: Direct(32947), source: Direct(32947), bit_size: Integer(U8) }, Cast { destination: Direct(32948), source: Direct(32948), bit_size: Integer(U8) }, Cast { destination: Direct(32949), source: Direct(32949), bit_size: Integer(U8) }, Cast { destination: Direct(32950), source: Direct(32950), bit_size: Integer(U8) }, Cast { destination: Direct(32951), source: Direct(32951), bit_size: Integer(U8) }, Cast { destination: Direct(32952), source: Direct(32952), bit_size: Integer(U8) }, Cast { destination: Direct(32953), source: Direct(32953), bit_size: Integer(U8) }, Cast { destination: Direct(32954), source: Direct(32954), bit_size: Integer(U8) }, Cast { destination: Direct(32955), source: Direct(32955), bit_size: Integer(U8) }, Cast { destination: Direct(32956), source: Direct(32956), bit_size: Integer(U8) }, Cast { destination: Direct(32957), source: Direct(32957), bit_size: Integer(U8) }, Cast { destination: Direct(32958), source: Direct(32958), bit_size: Integer(U8) }, Cast { destination: Direct(32959), source: Direct(32959), bit_size: Integer(U8) }, Cast { destination: Direct(32960), source: Direct(32960), bit_size: Integer(U8) }, Cast { destination: Direct(32961), source: Direct(32961), bit_size: Integer(U8) }, Cast { destination: Direct(32962), source: Direct(32962), bit_size: Integer(U8) }, Cast { destination: Direct(32963), source: Direct(32963), bit_size: Integer(U8) }, Cast { destination: Direct(32964), source: Direct(32964), bit_size: Integer(U8) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32836 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(1), source: Relative(5) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32868 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(2), source: Relative(5) }, Mov { destination: Relative(3), source: Direct(32932) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32933 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 188 }, Call { location: 189 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32965 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 187 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 180 }, Return, Return, Call { location: 339 }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Mov { destination: Relative(10), source: Relative(8) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 211 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 205 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 64 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 1 }, Mov { destination: Relative(5), source: Relative(3) }, Jump { location: 220 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(14), location: 250 }, Jump { location: 223 }, Load { destination: Relative(2), source_pointer: Relative(6) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 229 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(9) }, JumpIf { condition: Relative(3), location: 237 }, Jump { location: 232 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(1), location: 236 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Load { destination: Relative(3), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Load { destination: Relative(7), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(3), rhs: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 229 }, Load { destination: Relative(15), source_pointer: Relative(7) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(15) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 256 }, Call { location: 345 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(15) }, Mov { destination: Relative(15), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(7) }, BinaryIntOp { destination: Relative(17), op: Mul, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(1) }, Cast { destination: Relative(20), source: Relative(18), bit_size: Integer(U1) }, Cast { destination: Relative(19), source: Relative(20), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(19), rhs: Relative(3) }, Not { destination: Relative(19), source: Relative(18), bit_size: U1 }, Cast { destination: Relative(20), source: Relative(18), bit_size: Integer(U32) }, Cast { destination: Relative(18), source: Relative(19), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(19), op: Mul, bit_size: U32, lhs: Relative(18), rhs: Relative(9) }, BinaryIntOp { destination: Relative(18), op: Mul, bit_size: U32, lhs: Relative(20), rhs: Relative(9) }, Mov { destination: Relative(14), source: Relative(3) }, Jump { location: 273 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 292 }, Jump { location: 276 }, Load { destination: Relative(14), source_pointer: Relative(15) }, Mov { destination: Relative(15), source: Direct(1) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(16) }, IndirectConst { destination_pointer: Relative(15), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 64 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(16), size: Relative(17) }, output: HeapArray { pointer: Relative(18), size: 32 } }), Store { destination_pointer: Relative(6), source: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Shr, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Store { destination_pointer: Relative(1), source: Relative(15) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, Mov { destination: Relative(5), source: Relative(14) }, Jump { location: 220 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(19) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(16) }, JumpIf { condition: Relative(20), location: 296 }, Call { location: 348 }, Load { destination: Relative(20), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(14) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Load { destination: Relative(20), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, JumpIf { condition: Relative(22), location: 304 }, Call { location: 351 }, Mov { destination: Direct(32771), source: Relative(20) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 65 }, Call { location: 354 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(16) }, Store { destination_pointer: Relative(24), source: Relative(21) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(18) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(16) }, JumpIf { condition: Relative(20), location: 315 }, Call { location: 348 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(14) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(17), rhs: Relative(20) }, JumpIf { condition: Relative(21), location: 319 }, Call { location: 348 }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 322 }, Call { location: 351 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(20) }, Load { destination: Relative(21), source_pointer: Relative(24) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, JumpIf { condition: Relative(20), location: 328 }, Call { location: 351 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 65 }, Call { location: 354 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(16) }, Store { destination_pointer: Relative(24), source: Relative(21) }, Store { destination_pointer: Relative(15), source: Relative(20) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(11) }, Mov { destination: Relative(14), source: Relative(16) }, Jump { location: 273 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 344 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 358 }, Jump { location: 360 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 375 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 372 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 365 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 375 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32965 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 129 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U8) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U8) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U8) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U8) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Cast { destination: Direct(32881), source: Direct(32881), bit_size: Integer(U8) }, Cast { destination: Direct(32882), source: Direct(32882), bit_size: Integer(U8) }, Cast { destination: Direct(32883), source: Direct(32883), bit_size: Integer(U8) }, Cast { destination: Direct(32884), source: Direct(32884), bit_size: Integer(U8) }, Cast { destination: Direct(32885), source: Direct(32885), bit_size: Integer(U8) }, Cast { destination: Direct(32886), source: Direct(32886), bit_size: Integer(U8) }, Cast { destination: Direct(32887), source: Direct(32887), bit_size: Integer(U8) }, Cast { destination: Direct(32888), source: Direct(32888), bit_size: Integer(U8) }, Cast { destination: Direct(32889), source: Direct(32889), bit_size: Integer(U8) }, Cast { destination: Direct(32890), source: Direct(32890), bit_size: Integer(U8) }, Cast { destination: Direct(32891), source: Direct(32891), bit_size: Integer(U8) }, Cast { destination: Direct(32892), source: Direct(32892), bit_size: Integer(U8) }, Cast { destination: Direct(32893), source: Direct(32893), bit_size: Integer(U8) }, Cast { destination: Direct(32894), source: Direct(32894), bit_size: Integer(U8) }, Cast { destination: Direct(32895), source: Direct(32895), bit_size: Integer(U8) }, Cast { destination: Direct(32896), source: Direct(32896), bit_size: Integer(U8) }, Cast { destination: Direct(32897), source: Direct(32897), bit_size: Integer(U8) }, Cast { destination: Direct(32898), source: Direct(32898), bit_size: Integer(U8) }, Cast { destination: Direct(32899), source: Direct(32899), bit_size: Integer(U8) }, Cast { destination: Direct(32900), source: Direct(32900), bit_size: Integer(U8) }, Cast { destination: Direct(32901), source: Direct(32901), bit_size: Integer(U8) }, Cast { destination: Direct(32902), source: Direct(32902), bit_size: Integer(U8) }, Cast { destination: Direct(32903), source: Direct(32903), bit_size: Integer(U8) }, Cast { destination: Direct(32904), source: Direct(32904), bit_size: Integer(U8) }, Cast { destination: Direct(32905), source: Direct(32905), bit_size: Integer(U8) }, Cast { destination: Direct(32906), source: Direct(32906), bit_size: Integer(U8) }, Cast { destination: Direct(32907), source: Direct(32907), bit_size: Integer(U8) }, Cast { destination: Direct(32908), source: Direct(32908), bit_size: Integer(U8) }, Cast { destination: Direct(32909), source: Direct(32909), bit_size: Integer(U8) }, Cast { destination: Direct(32910), source: Direct(32910), bit_size: Integer(U8) }, Cast { destination: Direct(32911), source: Direct(32911), bit_size: Integer(U8) }, Cast { destination: Direct(32912), source: Direct(32912), bit_size: Integer(U8) }, Cast { destination: Direct(32913), source: Direct(32913), bit_size: Integer(U8) }, Cast { destination: Direct(32914), source: Direct(32914), bit_size: Integer(U8) }, Cast { destination: Direct(32915), source: Direct(32915), bit_size: Integer(U8) }, Cast { destination: Direct(32916), source: Direct(32916), bit_size: Integer(U8) }, Cast { destination: Direct(32917), source: Direct(32917), bit_size: Integer(U8) }, Cast { destination: Direct(32918), source: Direct(32918), bit_size: Integer(U8) }, Cast { destination: Direct(32919), source: Direct(32919), bit_size: Integer(U8) }, Cast { destination: Direct(32920), source: Direct(32920), bit_size: Integer(U8) }, Cast { destination: Direct(32921), source: Direct(32921), bit_size: Integer(U8) }, Cast { destination: Direct(32922), source: Direct(32922), bit_size: Integer(U8) }, Cast { destination: Direct(32923), source: Direct(32923), bit_size: Integer(U8) }, Cast { destination: Direct(32924), source: Direct(32924), bit_size: Integer(U8) }, Cast { destination: Direct(32925), source: Direct(32925), bit_size: Integer(U8) }, Cast { destination: Direct(32926), source: Direct(32926), bit_size: Integer(U8) }, Cast { destination: Direct(32927), source: Direct(32927), bit_size: Integer(U8) }, Cast { destination: Direct(32928), source: Direct(32928), bit_size: Integer(U8) }, Cast { destination: Direct(32929), source: Direct(32929), bit_size: Integer(U8) }, Cast { destination: Direct(32930), source: Direct(32930), bit_size: Integer(U8) }, Cast { destination: Direct(32931), source: Direct(32931), bit_size: Integer(U8) }, Cast { destination: Direct(32932), source: Direct(32932), bit_size: Integer(U32) }, Cast { destination: Direct(32933), source: Direct(32933), bit_size: Integer(U8) }, Cast { destination: Direct(32934), source: Direct(32934), bit_size: Integer(U8) }, Cast { destination: Direct(32935), source: Direct(32935), bit_size: Integer(U8) }, Cast { destination: Direct(32936), source: Direct(32936), bit_size: Integer(U8) }, Cast { destination: Direct(32937), source: Direct(32937), bit_size: Integer(U8) }, Cast { destination: Direct(32938), source: Direct(32938), bit_size: Integer(U8) }, Cast { destination: Direct(32939), source: Direct(32939), bit_size: Integer(U8) }, Cast { destination: Direct(32940), source: Direct(32940), bit_size: Integer(U8) }, Cast { destination: Direct(32941), source: Direct(32941), bit_size: Integer(U8) }, Cast { destination: Direct(32942), source: Direct(32942), bit_size: Integer(U8) }, Cast { destination: Direct(32943), source: Direct(32943), bit_size: Integer(U8) }, Cast { destination: Direct(32944), source: Direct(32944), bit_size: Integer(U8) }, Cast { destination: Direct(32945), source: Direct(32945), bit_size: Integer(U8) }, Cast { destination: Direct(32946), source: Direct(32946), bit_size: Integer(U8) }, Cast { destination: Direct(32947), source: Direct(32947), bit_size: Integer(U8) }, Cast { destination: Direct(32948), source: Direct(32948), bit_size: Integer(U8) }, Cast { destination: Direct(32949), source: Direct(32949), bit_size: Integer(U8) }, Cast { destination: Direct(32950), source: Direct(32950), bit_size: Integer(U8) }, Cast { destination: Direct(32951), source: Direct(32951), bit_size: Integer(U8) }, Cast { destination: Direct(32952), source: Direct(32952), bit_size: Integer(U8) }, Cast { destination: Direct(32953), source: Direct(32953), bit_size: Integer(U8) }, Cast { destination: Direct(32954), source: Direct(32954), bit_size: Integer(U8) }, Cast { destination: Direct(32955), source: Direct(32955), bit_size: Integer(U8) }, Cast { destination: Direct(32956), source: Direct(32956), bit_size: Integer(U8) }, Cast { destination: Direct(32957), source: Direct(32957), bit_size: Integer(U8) }, Cast { destination: Direct(32958), source: Direct(32958), bit_size: Integer(U8) }, Cast { destination: Direct(32959), source: Direct(32959), bit_size: Integer(U8) }, Cast { destination: Direct(32960), source: Direct(32960), bit_size: Integer(U8) }, Cast { destination: Direct(32961), source: Direct(32961), bit_size: Integer(U8) }, Cast { destination: Direct(32962), source: Direct(32962), bit_size: Integer(U8) }, Cast { destination: Direct(32963), source: Direct(32963), bit_size: Integer(U8) }, Cast { destination: Direct(32964), source: Direct(32964), bit_size: Integer(U8) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32836 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(1), source: Relative(5) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32868 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(2), source: Relative(5) }, Mov { destination: Relative(3), source: Direct(32932) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32933 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 177 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 188 }, Call { location: 189 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32965 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 187 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 180 }, Return, Return, Call { location: 338 }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Mov { destination: Relative(10), source: Relative(8) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 211 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 205 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(5), source: Relative(3) }, Jump { location: 219 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 249 }, Jump { location: 222 }, Load { destination: Relative(2), source_pointer: Relative(6) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 228 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(9) }, JumpIf { condition: Relative(3), location: 236 }, Jump { location: 231 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(1), location: 235 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Load { destination: Relative(3), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Load { destination: Relative(7), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(3), rhs: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 228 }, Load { destination: Relative(14), source_pointer: Relative(7) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(14) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 255 }, Call { location: 344 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Mov { destination: Relative(14), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(7) }, BinaryIntOp { destination: Relative(16), op: Mul, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, Load { destination: Relative(17), source_pointer: Relative(1) }, Cast { destination: Relative(19), source: Relative(17), bit_size: Integer(U1) }, Cast { destination: Relative(18), source: Relative(19), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(17), bit_size: U1 }, Cast { destination: Relative(19), source: Relative(17), bit_size: Integer(U32) }, Cast { destination: Relative(17), source: Relative(18), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(18), op: Mul, bit_size: U32, lhs: Relative(17), rhs: Relative(9) }, BinaryIntOp { destination: Relative(17), op: Mul, bit_size: U32, lhs: Relative(19), rhs: Relative(9) }, Mov { destination: Relative(13), source: Relative(3) }, Jump { location: 272 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(15), location: 291 }, Jump { location: 275 }, Load { destination: Relative(13), source_pointer: Relative(14) }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(15) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 64 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(15), size: Relative(16) }, output: HeapArray { pointer: Relative(17), size: 32 } }), Store { destination_pointer: Relative(6), source: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(14), op: Shr, bit_size: U32, lhs: Relative(13), rhs: Relative(11) }, Store { destination_pointer: Relative(1), source: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, Mov { destination: Relative(5), source: Relative(13) }, Jump { location: 219 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(18) }, BinaryIntOp { destination: Relative(19), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(19), location: 295 }, Call { location: 347 }, Load { destination: Relative(19), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(13) }, Load { destination: Relative(20), source_pointer: Relative(22) }, Load { destination: Relative(19), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 303 }, Call { location: 350 }, Mov { destination: Direct(32771), source: Relative(19) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 65 }, Call { location: 353 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(15) }, Store { destination_pointer: Relative(23), source: Relative(20) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(19), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(19), location: 314 }, Call { location: 347 }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(16), rhs: Relative(19) }, JumpIf { condition: Relative(20), location: 318 }, Call { location: 347 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(19), rhs: Relative(12) }, JumpIf { condition: Relative(20), location: 321 }, Call { location: 350 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(19) }, Load { destination: Relative(20), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, JumpIf { condition: Relative(19), location: 327 }, Call { location: 350 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 65 }, Call { location: 353 }, Mov { destination: Relative(19), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(15) }, Store { destination_pointer: Relative(23), source: Relative(20) }, Store { destination_pointer: Relative(14), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(11) }, Mov { destination: Relative(13), source: Relative(15) }, Jump { location: 272 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 343 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 357 }, Jump { location: 359 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 374 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 371 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 364 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 374 }, Return]" ], - "debug_symbols": "tZbRbqswDIbfhWsuSBzbyV5lmqauYxMSohVrj3Q09d2PDTbdLlpNOdpN/y8F/4kdE/hsXvuX8/vzML0dPpqHx8/mZR7GcXh/Hg/73Wk4TPLvZ9PpTygisRUNptEUTJMpmlLzAKpsmk3LorHrTINpNAXTZIqmZMqm2dT8gvlF0aQqPqgqPqyKpmQqcVkUZN6iKveTajJFU7b7ZL7QKRSD1DlICiEoRAdwELegy0q4TpPIlFdFWzZaGdDKgFYGtDKglQGtDGhlQCsDWhnI/EjXpHWg6KBr0opQchDPoDkSGbDeo9Vh/UfTZpknapKcHYpB7hyCQ3QAh+Sgc2nCmRx43aCcTcuqS2Np7ZbOWiA5oAM56PKiQnYoK4A22ArBITqAgzqDAjqQAztkh2KgrbaCOieF6AAOyUGdUYEc2CE7FANt3hWCgzqTAjgkB3QgB3bI6/aBdvkC0DkEh+gADskBHZY2uFzaxk+E59Pc93ogfDki5OA47uZ+OjUP03kc2+bPbjwvN30cd9Oip90sV6UR+ulVVAzfhrFXurTX6O52KCeLDSFs0fg9PPxauLSOxUvvVMRHyhYfqVTEE3vpKHc16YPnz+nm/PR78XL6bxtQSro6/NRAXhfFK9hBqTEIV4NINQbQXVeQ/3cFt1II8U4Vo57NaxUjdLcc7rQxBG9j4JrHgMDjOVbFb48R54r4VNDiU6lZPyJZPHLNY0zR8ye8nX+5s4NAvgMB+NqFofw4hW0JGGtKiOBbgKlmCzFs8bHmJEPibQuq5s9eQCw1Jzny1gLl+/xPMtrth/nbx+9FneZh9zL2Nnw7T/svV09/j37FP56P82Hfv57nXp2uX9Dy8wiYWmB8klerjAJzGzLLKCwXobSQkg6DDlNuAbuniy7tHw==", + "debug_symbols": "tZbdbqswDMffhete4DiOk73KNE2sYxMSohVrj3Q09d2PDTbdLlpNOdpN/78U/BkT+Gxe+5fz+/MwvR0+mofHz+ZlHsZxeH8eD/vuNBwm+fezafUHikjYiYJpMEXTaEqmqXlAVTbNpmXR0LamYBpM0TSakmkyZdNsav7A/IGso2gQf6Qq/lg1mpKp2GdRlPhFVe5PqmgaTZPdJ3GhVcgOxSBKaAAFcAgO4g00rRjXMJFMk6mlT5Y+WTvI2kHWDrJ2kLWDrB1k7SBrB5m/pDlpHxI4aE7akYQO4hO0xkQGrPdod1j/0bJZ4gQtktkhOxSD3DqAQ3BAB42lBWdySOsGZTbNqy4Dpr1bJmwBdIgO5KDpBQV2yA5lBdRJWwEcgoN6RoXoQA7JgR2yQzHQmQtRARyCAzqoZ1Igh+TADtmhGITWQT0nheCADtGBHJIDr9uHOuUrFANsHcAhOKBDdFjG4HLZNX4iPJ/mvtcD4csRIQfHsZv76dQ8TOdx3DV/uvG83PRx7KZFT90sV2UQ+ulVVBy+DWOvdNldrdvbphzNFgA2a/puDr9mLhNj9jIyFfYhZbMPqVTYJ/bWpdzWlI9eP8eb8dPv2cvpv21AKfHq4acO5HVRvIMtlhoHcHUQUo0DbK8Z5P/N4FYJEO50MejZvHYxYHvLw50xRvAxRq55DBK6PYcq++0x4lxhHwuZfSw1+RMlsyeueYxT8PoT3a6/3NlBTL4DgHydQig/LmFLgUJNCwl9CyjWbCHBZh9qTjJKvG1BVfzsDaRSc5ITbyNQvsd/klW3H+ZvH78X9TQP3cvY2/LtPO2/XD39PfoV/3g+zod9/3qee/V0/YKWn0ck3CHHJ3m1ygqYd5BZVrBcxLzDiLoEXUaWZXm6aGr/AA==", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n if result {\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use super::{Eq, max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0_u64, 1), 0);\n assert_eq(min(0_u64, 0), 0);\n assert_eq(min(1_u64, 1), 1);\n assert_eq(min(255_u8, 0), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0_u64, 1), 1);\n assert_eq(max(0_u64, 0), 0);\n assert_eq(max(1_u64, 1), 1);\n assert_eq(max(255_u8, 0), 255);\n }\n\n #[test]\n fn correctly_handles_unequal_length_slices() {\n let slice_1 = &[0, 1, 2, 3];\n let slice_2 = &[0, 1, 2];\n assert(!slice_1.eq(slice_2));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__expanded.snap index 939159893ff..de558158bab 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__expanded.snap @@ -17,8 +17,8 @@ fn main(x: u32, y: u32) { assert((wx & wy).inner == (ex & ey)); assert((wx | wy).inner == (ex | ey)); assert((wx ^ wy).inner == (ex ^ ey)); - assert((wy << (x as u8)).inner == (ey << (ex as u8))); - assert((wy >> (x as u8)).inner == (ey >> (ex as u8))); + assert((wy << wx).inner == (ey << ex)); + assert((wy >> wx).inner == (ey >> ex)); assert((wx == wy) == (ex == ey)); assert((wx < wy) == (ex < ey)); assert((wx <= wy) == (ex <= ey)); @@ -94,14 +94,14 @@ impl BitXor for Wrapper { } impl Shl for Wrapper { - fn shl(self, other: u8) -> Self { - Self::new(self.inner << other) + fn shl(self, other: Self) -> Self { + Self::new(self.inner << other.inner) } } impl Shr for Wrapper { - fn shr(self, other: u8) -> Self { - Self::new(self.inner >> other) + fn shr(self, other: Self) -> Self { + Self::new(self.inner >> other.inner) } } diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 1decc4a88d8..2958f0265d3 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -36,14 +36,14 @@ expression: artifact "error_kind": "string", "string": "attempt to add with overflow" }, - "5795655218219125583": { - "error_kind": "string", - "string": "Field failed to decompose into specified 8 limbs" - }, "7233212735005103307": { "error_kind": "string", "string": "attempt to multiply with overflow" }, + "10437400104653976995": { + "error_kind": "string", + "string": "Field failed to decompose into specified 6 limbs" + }, "14514982005979867414": { "error_kind": "string", "string": "attempt to bit-shift with overflow" @@ -52,7 +52,7 @@ expression: artifact }, "bytecode": [ "func 0", - "current witness index : _107", + "current witness index : _66", "private parameters indices : [_0, _1]", "public parameters indices : []", "return value indices : []", @@ -85,122 +85,76 @@ expression: artifact "EXPR [ (-1, _16) 4294967284 ]", "BLACKBOX::XOR [(_0, 32), (_1, 32)] [_17]", "EXPR [ (1, _17) -10 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 256 ]], outputs: [_18, _19]", - "BLACKBOX::RANGE [(_18, 24)] []", - "BLACKBOX::RANGE [(_19, 8)] []", - "EXPR [ (1, _0) (-256, _18) (-1, _19) 0 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _19) 224 ], EXPR [ 256 ]], outputs: [_20, _21]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) 4294967264 ], EXPR [ 4294967296 ]], outputs: [_18, _19]", + "BLACKBOX::RANGE [(_19, 32)] []", + "EXPR [ (1, _0) (-4294967296, _18) (-1, _19) 4294967264 ]", + "EXPR [ (-1, _18) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 6 ], EXPR [ 2 ]], outputs: [[_20, _21, _22, _23, _24, _25]]", "BLACKBOX::RANGE [(_20, 1)] []", - "BLACKBOX::RANGE [(_21, 8)] []", - "EXPR [ (1, _19) (-256, _20) (-1, _21) 224 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _19) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_22, _23, _24, _25, _26, _27, _28, _29]]", + "BLACKBOX::RANGE [(_21, 1)] []", "BLACKBOX::RANGE [(_22, 1)] []", "BLACKBOX::RANGE [(_23, 1)] []", "BLACKBOX::RANGE [(_24, 1)] []", "BLACKBOX::RANGE [(_25, 1)] []", - "BLACKBOX::RANGE [(_26, 1)] []", - "BLACKBOX::RANGE [(_27, 1)] []", - "BLACKBOX::RANGE [(_28, 1)] []", - "BLACKBOX::RANGE [(_29, 1)] []", - "EXPR [ (1, _19) (-1, _22) (-2, _23) (-4, _24) (-8, _25) (-16, _26) (-32, _27) (-64, _28) (-128, _29) 0 ]", - "EXPR [ (1, _29, _29) (2, _29) (-1, _30) 1 ]", - "EXPR [ (-1, _28) (-1, _31) 1 ]", - "EXPR [ (2, _28, _30) (1, _30, _31) (-1, _32) 0 ]", - "EXPR [ (1, _32, _32) (-1, _33) 0 ]", - "EXPR [ (-1, _27) (-1, _34) 1 ]", - "EXPR [ (2, _27, _33) (1, _33, _34) (-1, _35) 0 ]", - "EXPR [ (1, _35, _35) (-1, _36) 0 ]", - "EXPR [ (-1, _26) (-1, _37) 1 ]", - "EXPR [ (2, _26, _36) (1, _36, _37) (-1, _38) 0 ]", - "EXPR [ (1, _38, _38) (-1, _39) 0 ]", - "EXPR [ (-1, _25) (-1, _40) 1 ]", - "EXPR [ (2, _25, _39) (1, _39, _40) (-1, _41) 0 ]", - "EXPR [ (1, _41, _41) (-1, _42) 0 ]", - "EXPR [ (-1, _24) (-1, _43) 1 ]", - "EXPR [ (2, _24, _42) (1, _42, _43) (-1, _44) 0 ]", - "EXPR [ (1, _44, _44) (-1, _45) 0 ]", - "EXPR [ (-1, _23) (-1, _46) 1 ]", - "EXPR [ (2, _23, _45) (1, _45, _46) (-1, _47) 0 ]", - "EXPR [ (1, _47, _47) (-1, _48) 0 ]", - "EXPR [ (-1, _22) (-1, _49) 1 ]", - "EXPR [ (-1, _20) (-1, _50) 1 ]", - "EXPR [ (2, _22, _48) (1, _48, _49) (-1, _51) 0 ]", - "EXPR [ (1, _50, _51) (-1, _52) 0 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1, _52) 0 ], EXPR [ 4294967296 ]], outputs: [_53, _54]", - "BLACKBOX::RANGE [(_53, 222)] []", - "EXPR [ (1, _1, _52) (-4294967296, _53) (-1, _54) 0 ]", - "EXPR [ (-1, _53) (-1, _55) 5096253676302562286669017222071363378443840053029366383258766538131 ]", - "BLACKBOX::RANGE [(_55, 222)] []", - "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _53) 5096253676302562286669017222071363378443840053029366383258766538131 ]], outputs: [_56]", - "EXPR [ (-1, _53, _56) (5096253676302562286669017222071363378443840053029366383258766538131, _56) (1, _57) -1 ]", - "EXPR [ (-1, _53, _57) (5096253676302562286669017222071363378443840053029366383258766538131, _57) 0 ]", - "EXPR [ (1, _54, _57) (268435455, _57) (-1, _58) 0 ]", - "BLACKBOX::RANGE [(_58, 32)] []", - "EXPR [ (1, _50) -1 ]", - "EXPR [ (1, _54) -72 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _19) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_59, _60, _61, _62, _63, _64, _65, _66]]", - "BLACKBOX::RANGE [(_59, 1)] []", - "BLACKBOX::RANGE [(_60, 1)] []", - "BLACKBOX::RANGE [(_61, 1)] []", - "BLACKBOX::RANGE [(_62, 1)] []", - "BLACKBOX::RANGE [(_63, 1)] []", - "BLACKBOX::RANGE [(_64, 1)] []", - "BLACKBOX::RANGE [(_65, 1)] []", - "BLACKBOX::RANGE [(_66, 1)] []", - "EXPR [ (1, _19) (-1, _59) (-2, _60) (-4, _61) (-8, _62) (-16, _63) (-32, _64) (-64, _65) (-128, _66) 0 ]", - "EXPR [ (1, _66, _66) (2, _66) (-1, _67) 1 ]", - "EXPR [ (-1, _65) (-1, _68) 1 ]", - "EXPR [ (2, _65, _67) (1, _67, _68) (-1, _69) 0 ]", - "EXPR [ (1, _69, _69) (-1, _70) 0 ]", - "EXPR [ (-1, _64) (-1, _71) 1 ]", - "EXPR [ (2, _64, _70) (1, _70, _71) (-1, _72) 0 ]", - "EXPR [ (1, _72, _72) (-1, _73) 0 ]", - "EXPR [ (-1, _63) (-1, _74) 1 ]", - "EXPR [ (2, _63, _73) (1, _73, _74) (-1, _75) 0 ]", - "EXPR [ (1, _75, _75) (-1, _76) 0 ]", - "EXPR [ (-1, _62) (-1, _77) 1 ]", - "EXPR [ (2, _62, _76) (1, _76, _77) (-1, _78) 0 ]", - "EXPR [ (1, _78, _78) (-1, _79) 0 ]", - "EXPR [ (-1, _61) (-1, _80) 1 ]", - "EXPR [ (2, _61, _79) (1, _79, _80) (-1, _81) 0 ]", - "EXPR [ (1, _81, _81) (-1, _82) 0 ]", - "EXPR [ (-1, _60) (-1, _83) 1 ]", - "EXPR [ (2, _60, _82) (1, _82, _83) (-1, _84) 0 ]", - "EXPR [ (1, _84, _84) (-1, _85) 0 ]", - "EXPR [ (-1, _59) (-1, _86) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _85, _59) (1, _85, _86) 0 ]], outputs: [_87]", - "EXPR [ (2, _59, _85) (1, _85, _86) (-1, _88) 0 ]", - "EXPR [ (1, _87, _88) -1 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1) 0 ], EXPR [ (1, _88) 0 ]], outputs: [_89, _90]", - "BLACKBOX::RANGE [(_90, 32)] []", - "EXPR [ (1, _88) (-1, _90) (-1, _91) -1 ]", - "BLACKBOX::RANGE [(_91, 32)] []", - "EXPR [ (-1, _88, _89) (1, _1) (-1, _90) 0 ]", - "EXPR [ (1, _89) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) (-1, _1) 0 ]], outputs: [_92]", - "EXPR [ (1, _0, _92) (-1, _1, _92) -1 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) (-1, _1) 4294967296 ], EXPR [ 4294967296 ]], outputs: [_93, _94]", - "BLACKBOX::RANGE [(_93, 1)] []", - "BLACKBOX::RANGE [(_94, 32)] []", - "EXPR [ (1, _0) (-1, _1) (-4294967296, _93) (-1, _94) 4294967296 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _0) (1, _1) 4294967296 ], EXPR [ 4294967296 ]], outputs: [_95, _96]", - "BLACKBOX::RANGE [(_95, 1)] []", - "BLACKBOX::RANGE [(_96, 32)] []", - "EXPR [ (-1, _0) (1, _1) (-4294967296, _95) (-1, _96) 4294967296 ]", - "EXPR [ (-1, _93, _95) (2, _93) (-1, _97) 0 ]", - "EXPR [ (1, _93, _97) 0 ]", - "EXPR [ (-1, _93, _95) (2, _95) (-1, _98) 0 ]", - "EXPR [ (1, _95, _98) (-1, _99) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _99) 0 ]], outputs: [_100]", - "EXPR [ (1, _99, _100) (1, _101) -1 ]", - "EXPR [ (1, _99, _101) 0 ]", - "EXPR [ (1, _93, _101) (-1, _102) 0 ]", - "EXPR [ (-1, _95) (-1, _103) 1 ]", - "EXPR [ (1, _95, _102) (2, _102, _103) (-1, _104) 0 ]", - "EXPR [ (1, _102, _104) (-1, _105) 0 ]", - "EXPR [ (-1, _101) (-1, _106) 1 ]", - "EXPR [ (1, _95, _98) (-1, _107) 0 ]", - "EXPR [ (1, _101, _105) (1, _106, _107) -2 ]", + "EXPR [ (1, _0) (-1, _20) (-2, _21) (-4, _22) (-8, _23) (-16, _24) (-32, _25) 0 ]", + "EXPR [ (1, _25, _25) (2, _25) (-1, _26) 1 ]", + "EXPR [ (-1, _24) (-1, _27) 1 ]", + "EXPR [ (2, _24, _26) (1, _26, _27) (-1, _28) 0 ]", + "EXPR [ (1, _28, _28) (-1, _29) 0 ]", + "EXPR [ (-1, _23) (-1, _30) 1 ]", + "EXPR [ (2, _23, _29) (1, _29, _30) (-1, _31) 0 ]", + "EXPR [ (1, _31, _31) (-1, _32) 0 ]", + "EXPR [ (-1, _22) (-1, _33) 1 ]", + "EXPR [ (2, _22, _32) (1, _32, _33) (-1, _34) 0 ]", + "EXPR [ (1, _34, _34) (-1, _35) 0 ]", + "EXPR [ (-1, _21) (-1, _36) 1 ]", + "EXPR [ (2, _21, _35) (1, _35, _36) (-1, _37) 0 ]", + "EXPR [ (1, _37, _37) (-1, _38) 0 ]", + "EXPR [ (-1, _20) (-1, _39) 1 ]", + "EXPR [ (2, _20, _38) (1, _38, _39) (-1, _40) 0 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1, _40) 0 ], EXPR [ 4294967296 ]], outputs: [_41, _42]", + "BLACKBOX::RANGE [(_41, 222)] []", + "EXPR [ (1, _1, _40) (-4294967296, _41) (-1, _42) 0 ]", + "EXPR [ (-1, _41) (-1, _43) 5096253676302562286669017222071363378443840053029366383258766538131 ]", + "BLACKBOX::RANGE [(_43, 222)] []", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _41) 5096253676302562286669017222071363378443840053029366383258766538131 ]], outputs: [_44]", + "EXPR [ (-1, _41, _44) (5096253676302562286669017222071363378443840053029366383258766538131, _44) (1, _45) -1 ]", + "EXPR [ (-1, _41, _45) (5096253676302562286669017222071363378443840053029366383258766538131, _45) 0 ]", + "EXPR [ (1, _42, _45) (268435455, _45) (-1, _46) 0 ]", + "BLACKBOX::RANGE [(_46, 32)] []", + "EXPR [ (1, _42) -72 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _40) 0 ]], outputs: [_47]", + "EXPR [ (1, _40, _47) -1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1) 0 ], EXPR [ (1, _40) 0 ]], outputs: [_48, _49]", + "BLACKBOX::RANGE [(_49, 32)] []", + "EXPR [ (1, _40) (-1, _49) (-1, _50) -1 ]", + "BLACKBOX::RANGE [(_50, 32)] []", + "EXPR [ (-1, _40, _48) (1, _1) (-1, _49) 0 ]", + "EXPR [ (1, _48) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) (-1, _1) 0 ]], outputs: [_51]", + "EXPR [ (1, _0, _51) (-1, _1, _51) -1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) (-1, _1) 4294967296 ], EXPR [ 4294967296 ]], outputs: [_52, _53]", + "BLACKBOX::RANGE [(_52, 1)] []", + "BLACKBOX::RANGE [(_53, 32)] []", + "EXPR [ (1, _0) (-1, _1) (-4294967296, _52) (-1, _53) 4294967296 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _0) (1, _1) 4294967296 ], EXPR [ 4294967296 ]], outputs: [_54, _55]", + "BLACKBOX::RANGE [(_54, 1)] []", + "BLACKBOX::RANGE [(_55, 32)] []", + "EXPR [ (-1, _0) (1, _1) (-4294967296, _54) (-1, _55) 4294967296 ]", + "EXPR [ (-1, _52, _54) (2, _52) (-1, _56) 0 ]", + "EXPR [ (1, _52, _56) 0 ]", + "EXPR [ (-1, _52, _54) (2, _54) (-1, _57) 0 ]", + "EXPR [ (1, _54, _57) (-1, _58) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _58) 0 ]], outputs: [_59]", + "EXPR [ (1, _58, _59) (1, _60) -1 ]", + "EXPR [ (1, _58, _60) 0 ]", + "EXPR [ (1, _52, _60) (-1, _61) 0 ]", + "EXPR [ (-1, _54) (-1, _62) 1 ]", + "EXPR [ (1, _54, _61) (2, _61, _62) (-1, _63) 0 ]", + "EXPR [ (1, _61, _63) (-1, _64) 0 ]", + "EXPR [ (-1, _60) (-1, _65) 1 ]", + "EXPR [ (1, _54, _57) (-1, _66) 0 ]", + "EXPR [ (1, _60, _64) (1, _65, _66) -2 ]", "unconstrained func 0", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]", "unconstrained func 1", @@ -208,14 +162,14 @@ expression: artifact "unconstrained func 2", "[Const { destination: Direct(5), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(6), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(7), bit_size: Integer(U32), value: 3 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(7), offset_address: Direct(5) }, Cast { destination: Direct(1), source: Direct(1), bit_size: Integer(U32) }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(7), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(3), op: IntegerDiv, lhs: Direct(0), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Mul, lhs: Direct(3), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Sub, lhs: Direct(0), rhs: Direct(4) }, Store { destination_pointer: Direct(9), source: Direct(4) }, BinaryIntOp { destination: Direct(9), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(6) }, Mov { destination: Direct(0), source: Direct(3) }, BinaryIntOp { destination: Direct(8), op: LessThan, bit_size: U32, lhs: Direct(9), rhs: Direct(7) }, JumpIf { condition: Direct(8), location: 7 }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, Stop { return_data: HeapVector { pointer: Direct(9), size: Direct(1) } }]" ], - "debug_symbols": "pZhBbhsxDEXvMmsvhpRISrlKUQROMikMGE7g2gWKIHevlPmcJAuprbL6tCd64ZdISZ6X6WG5u/64PZwen35ON99eprvz4Xg8/Lg9Pt3vL4enU/n25XU3+cfby3lZylfTh+dl1PP+vJwu083pejzupl/74/Xtj34+709vetmfy9N5Ny2nh6IF+Hg4LjV63b2PnttDORsGhzluw+XzeGqPJ+UEAKlwi9DNQD0DHhkfwuYgNh3EjgOLDiAzGspgc6BDDmxzkJoOrOMgqSdAKc9DGTggziMOIrmDyO0q6gAoJwGB5zkPpbBZiEMWZLOgbQuhU8c0R7dAnIZS2CykIQvZW1FmaVrQjgXm7BZYwlAKPovCMjBeou9lEq1pIXcsBGG3UKp6JIXgcyBqI+OTJyCpWcjMHQtx2w9YZhpKgQDQoV7SsI0PI4WsLH8fz71ClLz1klIYSsEBqiOFqMkLUXPz/3OvEG32bmYb6gU1L0TjkU3dgq+CyUgVmPkUWmpWYejtiJm2TT1zM4XQOZxFeNsQJHzYFP+D8N6PpaoahO40BJ+GPLKMRFs7E7fbMaTO8cxG2x0pjewIVMrRkwjtIz727giU35Nob0uRvlwQkb+6nF0fvJVU4PYhEzs1Fd7PiCCqQ0n804pG/fpk2le7q09oLsf38mF/fzh/+sUzcTG8m0LZ3XZTnG7KNEptkd2kq9gqaZW8Cs1QgnKt6KKFQ2WdKEIFqlCDJmhelSuvTB5XXnHHlVf6j0O9fhaNUIFqvdMVtXqrKJrqKV0016Oq2JmhBGVo5RV+iFCBKtSgCZpXjTOUoAwFL4IXwYvgRfAieBE8AU/AE/AEPAFPwBPwBDwBT8BT8BQ8BU/BU/AUPAVPwVPwFDwDz8Az8Aw8A8/AM/AMPAPPwEvgpcor65pq1ZV1TAEaoQJVqEETNK+aZyhBwcvgZfAyeBm8DF4GL4NH8+wBecAeBA+iB+KBemAeJA+cTE4mJ5OTycnkZHIyOZmcTE4mJ9emCW/NV8m1+2rbrEElSw2iB+KBelDJWoPkQUZQ22cNKtBqEOuvoRqIB+qBeZDqz40aZAS1XeqOSbVf1iB4UIH1EvVrfz7s744LXr88Xk/3H97GXH4/+xN/X/N8frpfHq7npe5jb8/KzvYH", + "debug_symbols": "pZdBbuMwDEXv4nUWEkVSUq8yGBRu6hYBjCRwkwKDoncfqf5y04WEGWX1kjj84JdIWvoYnqen6+vj4fhyehsefn0MT8thng+vj/NpP14Op2P69eNzN5Svj5dlmtJPw83zFHUel+l4GR6O13neDe/jfP3609t5PH7xMi7pqdkN0/E5MQm+HOYpf/rcfUebeihFj2BneAuXn/G2Hm/VKASsOlNTaGZQBBxRR7xzmwOuOuCGA09SHHiOXRlsDrTLgd8chKoD33AQmIuDoKErg+KATY8DtsUBU72KGgI2qisWYvBdKWwWuMuCbBa0bsE16tgEggJZo10pbBZCl4UYEC9Gqha0YYFMWQQiZ7tSKAJC0hEvXGaZcLUKbGxYcK4okBPuScHFkoL2FKJsZSChOk2IGhZYykAi9rErBQsBNT3xuk1Eda5qQRoWxJeJRBL7UigC2rWLqmUX1Vd3kULDgsbNgrddFrS0o8aeoextGYne9RSil1KIXqr5u1YhRlMWkSJVC8E1hqIIbQ0t7mao/YfCdz9J5IpCcxlKM3jvOpbR2q0dra2/mlzjBe1IZTvj+J65aIlLMVkK1WOWa0xGZ8OWhI3VJNjcXRBs793Opg+yvC0mV19S3Kgp9z3jnah2JfFPO8py/2Lqvd3VVqhux+/0Zdwflh83loGS4d3g0kzbDTw8JAeS+2I36Aq/IqyIK6wBLUi5jBOTTt5My6CACnowgHElZb20tJT1Ut9R1kv9QS4fwxIZFFDzmSzR51NBYsiv1sSY53yyY0ALEuhABgVU0IMBhB5Dj6HH0GPoMfQYegw9hh5Dj6En0BPoCfQEegI9gZ5AT6An0BPoKfQUego9hZ5CT6GnWS+ts2a9tOUawLjSG9CCBDqQ8/UyUfLsSVTQ50tbYgDjymBAmxs0kUAHMph1Un4h5FN/YlwZDWhBykfqRAfK2ppRQQ/mPPKr8n1cDuPTPOGS/nI97m/u7Jc/5/Kk3OrPy2k/PV+XKXfL17PUP38B", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n if result {\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use super::{Eq, max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0_u64, 1), 0);\n assert_eq(min(0_u64, 0), 0);\n assert_eq(min(1_u64, 1), 1);\n assert_eq(min(255_u8, 0), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0_u64, 1), 1);\n assert_eq(max(0_u64, 0), 0);\n assert_eq(max(1_u64, 1), 1);\n assert_eq(max(255_u8, 0), 255);\n }\n\n #[test]\n fn correctly_handles_unequal_length_slices() {\n let slice_1 = &[0, 1, 2, 3];\n let slice_2 = &[0, 1, 2];\n assert(!slice_1.eq(slice_2));\n }\n}\n", "path": "std/cmp.nr" }, "50": { - "source": "use std::cmp::Ordering;\nuse std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Rem, Shl, Shr, Sub};\n\n// x = 3, y = 9\nfn main(x: u32, y: u32) {\n let wx = Wrapper::new(x);\n let wy = Wrapper::new(y);\n\n // expected x and expected y values\n let ex: u32 = 3;\n let ey: u32 = 9;\n\n assert((wx + wy).inner == ex + ey);\n assert((wy - wx).inner == ey - ex);\n assert((wx * wy).inner == ex * ey);\n assert((wx / wy).inner == ex / ey);\n assert((wx % wy).inner == ex % ey);\n\n assert((wx & wy).inner == (ex & ey));\n assert((wx | wy).inner == (ex | ey));\n assert((wx ^ wy).inner == (ex ^ ey));\n\n assert((wy << x as u8).inner == (ey << ex as u8));\n assert((wy >> x as u8).inner == (ey >> ex as u8));\n\n assert((wx == wy) == (ex == ey));\n assert((wx < wy) == (ex < ey));\n assert((wx <= wy) == (ex <= ey));\n assert((wx > wy) == (ex > ey));\n assert((wx >= wy) == (ex >= ey));\n assert(wx.cmp(wy) == ex.cmp(ey));\n\n // Ensure operator overloading still works with more complex types\n let pair_ascending = Pair { x: wx, y: wy };\n let pair_descending = Pair { x: wy, y: wx };\n\n assert(pair_ascending != pair_descending);\n\n assert(pair_ascending < pair_descending);\n assert(pair_ascending <= pair_descending);\n assert(pair_descending > pair_ascending);\n assert(pair_descending >= pair_ascending);\n\n assert(pair_ascending.cmp(pair_descending) == Ordering::less());\n}\n\nstruct Wrapper {\n inner: u32,\n}\n\nimpl Wrapper {\n fn new(inner: u32) -> Self {\n Wrapper { inner }\n }\n}\n\nimpl Add for Wrapper {\n fn add(self, other: Self) -> Self {\n Wrapper::new(self.inner + other.inner)\n }\n}\n\nimpl Sub for Wrapper {\n fn sub(self, other: Self) -> Self {\n Wrapper::new(self.inner - other.inner)\n }\n}\n\nimpl Mul for Wrapper {\n fn mul(self, other: Self) -> Self {\n Wrapper::new(self.inner * other.inner)\n }\n}\n\nimpl Div for Wrapper {\n fn div(self, other: Self) -> Self {\n Wrapper::new(self.inner / other.inner)\n }\n}\n\nimpl Rem for Wrapper {\n fn rem(self, other: Self) -> Self {\n Wrapper::new(self.inner % other.inner)\n }\n}\n\nimpl BitAnd for Wrapper {\n fn bitand(self, other: Self) -> Self {\n Wrapper::new(self.inner & other.inner)\n }\n}\n\nimpl BitOr for Wrapper {\n fn bitor(self, other: Self) -> Self {\n Wrapper::new(self.inner | other.inner)\n }\n}\n\nimpl BitXor for Wrapper {\n fn bitxor(self, other: Self) -> Self {\n Wrapper::new(self.inner ^ other.inner)\n }\n}\n\nimpl Shl for Wrapper {\n fn shl(self, other: u8) -> Self {\n Wrapper::new(self.inner << other)\n }\n}\n\nimpl Shr for Wrapper {\n fn shr(self, other: u8) -> Self {\n Wrapper::new(self.inner >> other)\n }\n}\n\nimpl Eq for Wrapper {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nimpl Ord for Wrapper {\n fn cmp(self, other: Self) -> Ordering {\n self.inner.cmp(other.inner)\n }\n}\n\nstruct Pair {\n x: Wrapper,\n y: Wrapper,\n}\n\nimpl Eq for Pair {\n fn eq(self, o: Self) -> bool {\n (self.x == o.x) & (self.y == o.y)\n }\n}\n\nimpl Ord for Pair {\n fn cmp(self, o: Self) -> Ordering {\n let mut result = self.x.cmp(o.x);\n\n if result == Ordering::equal() {\n result = self.y.cmp(o.y);\n }\n\n result\n }\n}\n", + "source": "use std::cmp::Ordering;\nuse std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Rem, Shl, Shr, Sub};\n\n// x = 3, y = 9\nfn main(x: u32, y: u32) {\n let wx = Wrapper::new(x);\n let wy = Wrapper::new(y);\n\n // expected x and expected y values\n let ex: u32 = 3;\n let ey: u32 = 9;\n\n assert((wx + wy).inner == ex + ey);\n assert((wy - wx).inner == ey - ex);\n assert((wx * wy).inner == ex * ey);\n assert((wx / wy).inner == ex / ey);\n assert((wx % wy).inner == ex % ey);\n\n assert((wx & wy).inner == (ex & ey));\n assert((wx | wy).inner == (ex | ey));\n assert((wx ^ wy).inner == (ex ^ ey));\n\n assert((wy << wx).inner == (ey << ex));\n assert((wy >> wx).inner == (ey >> ex));\n\n assert((wx == wy) == (ex == ey));\n assert((wx < wy) == (ex < ey));\n assert((wx <= wy) == (ex <= ey));\n assert((wx > wy) == (ex > ey));\n assert((wx >= wy) == (ex >= ey));\n assert(wx.cmp(wy) == ex.cmp(ey));\n\n // Ensure operator overloading still works with more complex types\n let pair_ascending = Pair { x: wx, y: wy };\n let pair_descending = Pair { x: wy, y: wx };\n\n assert(pair_ascending != pair_descending);\n\n assert(pair_ascending < pair_descending);\n assert(pair_ascending <= pair_descending);\n assert(pair_descending > pair_ascending);\n assert(pair_descending >= pair_ascending);\n\n assert(pair_ascending.cmp(pair_descending) == Ordering::less());\n}\n\nstruct Wrapper {\n inner: u32,\n}\n\nimpl Wrapper {\n fn new(inner: u32) -> Self {\n Wrapper { inner }\n }\n}\n\nimpl Add for Wrapper {\n fn add(self, other: Self) -> Self {\n Wrapper::new(self.inner + other.inner)\n }\n}\n\nimpl Sub for Wrapper {\n fn sub(self, other: Self) -> Self {\n Wrapper::new(self.inner - other.inner)\n }\n}\n\nimpl Mul for Wrapper {\n fn mul(self, other: Self) -> Self {\n Wrapper::new(self.inner * other.inner)\n }\n}\n\nimpl Div for Wrapper {\n fn div(self, other: Self) -> Self {\n Wrapper::new(self.inner / other.inner)\n }\n}\n\nimpl Rem for Wrapper {\n fn rem(self, other: Self) -> Self {\n Wrapper::new(self.inner % other.inner)\n }\n}\n\nimpl BitAnd for Wrapper {\n fn bitand(self, other: Self) -> Self {\n Wrapper::new(self.inner & other.inner)\n }\n}\n\nimpl BitOr for Wrapper {\n fn bitor(self, other: Self) -> Self {\n Wrapper::new(self.inner | other.inner)\n }\n}\n\nimpl BitXor for Wrapper {\n fn bitxor(self, other: Self) -> Self {\n Wrapper::new(self.inner ^ other.inner)\n }\n}\n\nimpl Shl for Wrapper {\n fn shl(self, other: Self) -> Self {\n Wrapper::new(self.inner << other.inner)\n }\n}\n\nimpl Shr for Wrapper {\n fn shr(self, other: Self) -> Self {\n Wrapper::new(self.inner >> other.inner)\n }\n}\n\nimpl Eq for Wrapper {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nimpl Ord for Wrapper {\n fn cmp(self, other: Self) -> Ordering {\n self.inner.cmp(other.inner)\n }\n}\n\nstruct Pair {\n x: Wrapper,\n y: Wrapper,\n}\n\nimpl Eq for Pair {\n fn eq(self, o: Self) -> bool {\n (self.x == o.x) & (self.y == o.y)\n }\n}\n\nimpl Ord for Pair {\n fn cmp(self, o: Self) -> Ordering {\n let mut result = self.x.cmp(o.x);\n\n if result == Ordering::equal() {\n result = self.y.cmp(o.y);\n }\n\n result\n }\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_false_inliner_0.snap index 1decc4a88d8..2958f0265d3 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_false_inliner_0.snap @@ -36,14 +36,14 @@ expression: artifact "error_kind": "string", "string": "attempt to add with overflow" }, - "5795655218219125583": { - "error_kind": "string", - "string": "Field failed to decompose into specified 8 limbs" - }, "7233212735005103307": { "error_kind": "string", "string": "attempt to multiply with overflow" }, + "10437400104653976995": { + "error_kind": "string", + "string": "Field failed to decompose into specified 6 limbs" + }, "14514982005979867414": { "error_kind": "string", "string": "attempt to bit-shift with overflow" @@ -52,7 +52,7 @@ expression: artifact }, "bytecode": [ "func 0", - "current witness index : _107", + "current witness index : _66", "private parameters indices : [_0, _1]", "public parameters indices : []", "return value indices : []", @@ -85,122 +85,76 @@ expression: artifact "EXPR [ (-1, _16) 4294967284 ]", "BLACKBOX::XOR [(_0, 32), (_1, 32)] [_17]", "EXPR [ (1, _17) -10 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 256 ]], outputs: [_18, _19]", - "BLACKBOX::RANGE [(_18, 24)] []", - "BLACKBOX::RANGE [(_19, 8)] []", - "EXPR [ (1, _0) (-256, _18) (-1, _19) 0 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _19) 224 ], EXPR [ 256 ]], outputs: [_20, _21]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) 4294967264 ], EXPR [ 4294967296 ]], outputs: [_18, _19]", + "BLACKBOX::RANGE [(_19, 32)] []", + "EXPR [ (1, _0) (-4294967296, _18) (-1, _19) 4294967264 ]", + "EXPR [ (-1, _18) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 6 ], EXPR [ 2 ]], outputs: [[_20, _21, _22, _23, _24, _25]]", "BLACKBOX::RANGE [(_20, 1)] []", - "BLACKBOX::RANGE [(_21, 8)] []", - "EXPR [ (1, _19) (-256, _20) (-1, _21) 224 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _19) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_22, _23, _24, _25, _26, _27, _28, _29]]", + "BLACKBOX::RANGE [(_21, 1)] []", "BLACKBOX::RANGE [(_22, 1)] []", "BLACKBOX::RANGE [(_23, 1)] []", "BLACKBOX::RANGE [(_24, 1)] []", "BLACKBOX::RANGE [(_25, 1)] []", - "BLACKBOX::RANGE [(_26, 1)] []", - "BLACKBOX::RANGE [(_27, 1)] []", - "BLACKBOX::RANGE [(_28, 1)] []", - "BLACKBOX::RANGE [(_29, 1)] []", - "EXPR [ (1, _19) (-1, _22) (-2, _23) (-4, _24) (-8, _25) (-16, _26) (-32, _27) (-64, _28) (-128, _29) 0 ]", - "EXPR [ (1, _29, _29) (2, _29) (-1, _30) 1 ]", - "EXPR [ (-1, _28) (-1, _31) 1 ]", - "EXPR [ (2, _28, _30) (1, _30, _31) (-1, _32) 0 ]", - "EXPR [ (1, _32, _32) (-1, _33) 0 ]", - "EXPR [ (-1, _27) (-1, _34) 1 ]", - "EXPR [ (2, _27, _33) (1, _33, _34) (-1, _35) 0 ]", - "EXPR [ (1, _35, _35) (-1, _36) 0 ]", - "EXPR [ (-1, _26) (-1, _37) 1 ]", - "EXPR [ (2, _26, _36) (1, _36, _37) (-1, _38) 0 ]", - "EXPR [ (1, _38, _38) (-1, _39) 0 ]", - "EXPR [ (-1, _25) (-1, _40) 1 ]", - "EXPR [ (2, _25, _39) (1, _39, _40) (-1, _41) 0 ]", - "EXPR [ (1, _41, _41) (-1, _42) 0 ]", - "EXPR [ (-1, _24) (-1, _43) 1 ]", - "EXPR [ (2, _24, _42) (1, _42, _43) (-1, _44) 0 ]", - "EXPR [ (1, _44, _44) (-1, _45) 0 ]", - "EXPR [ (-1, _23) (-1, _46) 1 ]", - "EXPR [ (2, _23, _45) (1, _45, _46) (-1, _47) 0 ]", - "EXPR [ (1, _47, _47) (-1, _48) 0 ]", - "EXPR [ (-1, _22) (-1, _49) 1 ]", - "EXPR [ (-1, _20) (-1, _50) 1 ]", - "EXPR [ (2, _22, _48) (1, _48, _49) (-1, _51) 0 ]", - "EXPR [ (1, _50, _51) (-1, _52) 0 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1, _52) 0 ], EXPR [ 4294967296 ]], outputs: [_53, _54]", - "BLACKBOX::RANGE [(_53, 222)] []", - "EXPR [ (1, _1, _52) (-4294967296, _53) (-1, _54) 0 ]", - "EXPR [ (-1, _53) (-1, _55) 5096253676302562286669017222071363378443840053029366383258766538131 ]", - "BLACKBOX::RANGE [(_55, 222)] []", - "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _53) 5096253676302562286669017222071363378443840053029366383258766538131 ]], outputs: [_56]", - "EXPR [ (-1, _53, _56) (5096253676302562286669017222071363378443840053029366383258766538131, _56) (1, _57) -1 ]", - "EXPR [ (-1, _53, _57) (5096253676302562286669017222071363378443840053029366383258766538131, _57) 0 ]", - "EXPR [ (1, _54, _57) (268435455, _57) (-1, _58) 0 ]", - "BLACKBOX::RANGE [(_58, 32)] []", - "EXPR [ (1, _50) -1 ]", - "EXPR [ (1, _54) -72 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _19) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_59, _60, _61, _62, _63, _64, _65, _66]]", - "BLACKBOX::RANGE [(_59, 1)] []", - "BLACKBOX::RANGE [(_60, 1)] []", - "BLACKBOX::RANGE [(_61, 1)] []", - "BLACKBOX::RANGE [(_62, 1)] []", - "BLACKBOX::RANGE [(_63, 1)] []", - "BLACKBOX::RANGE [(_64, 1)] []", - "BLACKBOX::RANGE [(_65, 1)] []", - "BLACKBOX::RANGE [(_66, 1)] []", - "EXPR [ (1, _19) (-1, _59) (-2, _60) (-4, _61) (-8, _62) (-16, _63) (-32, _64) (-64, _65) (-128, _66) 0 ]", - "EXPR [ (1, _66, _66) (2, _66) (-1, _67) 1 ]", - "EXPR [ (-1, _65) (-1, _68) 1 ]", - "EXPR [ (2, _65, _67) (1, _67, _68) (-1, _69) 0 ]", - "EXPR [ (1, _69, _69) (-1, _70) 0 ]", - "EXPR [ (-1, _64) (-1, _71) 1 ]", - "EXPR [ (2, _64, _70) (1, _70, _71) (-1, _72) 0 ]", - "EXPR [ (1, _72, _72) (-1, _73) 0 ]", - "EXPR [ (-1, _63) (-1, _74) 1 ]", - "EXPR [ (2, _63, _73) (1, _73, _74) (-1, _75) 0 ]", - "EXPR [ (1, _75, _75) (-1, _76) 0 ]", - "EXPR [ (-1, _62) (-1, _77) 1 ]", - "EXPR [ (2, _62, _76) (1, _76, _77) (-1, _78) 0 ]", - "EXPR [ (1, _78, _78) (-1, _79) 0 ]", - "EXPR [ (-1, _61) (-1, _80) 1 ]", - "EXPR [ (2, _61, _79) (1, _79, _80) (-1, _81) 0 ]", - "EXPR [ (1, _81, _81) (-1, _82) 0 ]", - "EXPR [ (-1, _60) (-1, _83) 1 ]", - "EXPR [ (2, _60, _82) (1, _82, _83) (-1, _84) 0 ]", - "EXPR [ (1, _84, _84) (-1, _85) 0 ]", - "EXPR [ (-1, _59) (-1, _86) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _85, _59) (1, _85, _86) 0 ]], outputs: [_87]", - "EXPR [ (2, _59, _85) (1, _85, _86) (-1, _88) 0 ]", - "EXPR [ (1, _87, _88) -1 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1) 0 ], EXPR [ (1, _88) 0 ]], outputs: [_89, _90]", - "BLACKBOX::RANGE [(_90, 32)] []", - "EXPR [ (1, _88) (-1, _90) (-1, _91) -1 ]", - "BLACKBOX::RANGE [(_91, 32)] []", - "EXPR [ (-1, _88, _89) (1, _1) (-1, _90) 0 ]", - "EXPR [ (1, _89) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) (-1, _1) 0 ]], outputs: [_92]", - "EXPR [ (1, _0, _92) (-1, _1, _92) -1 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) (-1, _1) 4294967296 ], EXPR [ 4294967296 ]], outputs: [_93, _94]", - "BLACKBOX::RANGE [(_93, 1)] []", - "BLACKBOX::RANGE [(_94, 32)] []", - "EXPR [ (1, _0) (-1, _1) (-4294967296, _93) (-1, _94) 4294967296 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _0) (1, _1) 4294967296 ], EXPR [ 4294967296 ]], outputs: [_95, _96]", - "BLACKBOX::RANGE [(_95, 1)] []", - "BLACKBOX::RANGE [(_96, 32)] []", - "EXPR [ (-1, _0) (1, _1) (-4294967296, _95) (-1, _96) 4294967296 ]", - "EXPR [ (-1, _93, _95) (2, _93) (-1, _97) 0 ]", - "EXPR [ (1, _93, _97) 0 ]", - "EXPR [ (-1, _93, _95) (2, _95) (-1, _98) 0 ]", - "EXPR [ (1, _95, _98) (-1, _99) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _99) 0 ]], outputs: [_100]", - "EXPR [ (1, _99, _100) (1, _101) -1 ]", - "EXPR [ (1, _99, _101) 0 ]", - "EXPR [ (1, _93, _101) (-1, _102) 0 ]", - "EXPR [ (-1, _95) (-1, _103) 1 ]", - "EXPR [ (1, _95, _102) (2, _102, _103) (-1, _104) 0 ]", - "EXPR [ (1, _102, _104) (-1, _105) 0 ]", - "EXPR [ (-1, _101) (-1, _106) 1 ]", - "EXPR [ (1, _95, _98) (-1, _107) 0 ]", - "EXPR [ (1, _101, _105) (1, _106, _107) -2 ]", + "EXPR [ (1, _0) (-1, _20) (-2, _21) (-4, _22) (-8, _23) (-16, _24) (-32, _25) 0 ]", + "EXPR [ (1, _25, _25) (2, _25) (-1, _26) 1 ]", + "EXPR [ (-1, _24) (-1, _27) 1 ]", + "EXPR [ (2, _24, _26) (1, _26, _27) (-1, _28) 0 ]", + "EXPR [ (1, _28, _28) (-1, _29) 0 ]", + "EXPR [ (-1, _23) (-1, _30) 1 ]", + "EXPR [ (2, _23, _29) (1, _29, _30) (-1, _31) 0 ]", + "EXPR [ (1, _31, _31) (-1, _32) 0 ]", + "EXPR [ (-1, _22) (-1, _33) 1 ]", + "EXPR [ (2, _22, _32) (1, _32, _33) (-1, _34) 0 ]", + "EXPR [ (1, _34, _34) (-1, _35) 0 ]", + "EXPR [ (-1, _21) (-1, _36) 1 ]", + "EXPR [ (2, _21, _35) (1, _35, _36) (-1, _37) 0 ]", + "EXPR [ (1, _37, _37) (-1, _38) 0 ]", + "EXPR [ (-1, _20) (-1, _39) 1 ]", + "EXPR [ (2, _20, _38) (1, _38, _39) (-1, _40) 0 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1, _40) 0 ], EXPR [ 4294967296 ]], outputs: [_41, _42]", + "BLACKBOX::RANGE [(_41, 222)] []", + "EXPR [ (1, _1, _40) (-4294967296, _41) (-1, _42) 0 ]", + "EXPR [ (-1, _41) (-1, _43) 5096253676302562286669017222071363378443840053029366383258766538131 ]", + "BLACKBOX::RANGE [(_43, 222)] []", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _41) 5096253676302562286669017222071363378443840053029366383258766538131 ]], outputs: [_44]", + "EXPR [ (-1, _41, _44) (5096253676302562286669017222071363378443840053029366383258766538131, _44) (1, _45) -1 ]", + "EXPR [ (-1, _41, _45) (5096253676302562286669017222071363378443840053029366383258766538131, _45) 0 ]", + "EXPR [ (1, _42, _45) (268435455, _45) (-1, _46) 0 ]", + "BLACKBOX::RANGE [(_46, 32)] []", + "EXPR [ (1, _42) -72 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _40) 0 ]], outputs: [_47]", + "EXPR [ (1, _40, _47) -1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1) 0 ], EXPR [ (1, _40) 0 ]], outputs: [_48, _49]", + "BLACKBOX::RANGE [(_49, 32)] []", + "EXPR [ (1, _40) (-1, _49) (-1, _50) -1 ]", + "BLACKBOX::RANGE [(_50, 32)] []", + "EXPR [ (-1, _40, _48) (1, _1) (-1, _49) 0 ]", + "EXPR [ (1, _48) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) (-1, _1) 0 ]], outputs: [_51]", + "EXPR [ (1, _0, _51) (-1, _1, _51) -1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) (-1, _1) 4294967296 ], EXPR [ 4294967296 ]], outputs: [_52, _53]", + "BLACKBOX::RANGE [(_52, 1)] []", + "BLACKBOX::RANGE [(_53, 32)] []", + "EXPR [ (1, _0) (-1, _1) (-4294967296, _52) (-1, _53) 4294967296 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _0) (1, _1) 4294967296 ], EXPR [ 4294967296 ]], outputs: [_54, _55]", + "BLACKBOX::RANGE [(_54, 1)] []", + "BLACKBOX::RANGE [(_55, 32)] []", + "EXPR [ (-1, _0) (1, _1) (-4294967296, _54) (-1, _55) 4294967296 ]", + "EXPR [ (-1, _52, _54) (2, _52) (-1, _56) 0 ]", + "EXPR [ (1, _52, _56) 0 ]", + "EXPR [ (-1, _52, _54) (2, _54) (-1, _57) 0 ]", + "EXPR [ (1, _54, _57) (-1, _58) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _58) 0 ]], outputs: [_59]", + "EXPR [ (1, _58, _59) (1, _60) -1 ]", + "EXPR [ (1, _58, _60) 0 ]", + "EXPR [ (1, _52, _60) (-1, _61) 0 ]", + "EXPR [ (-1, _54) (-1, _62) 1 ]", + "EXPR [ (1, _54, _61) (2, _61, _62) (-1, _63) 0 ]", + "EXPR [ (1, _61, _63) (-1, _64) 0 ]", + "EXPR [ (-1, _60) (-1, _65) 1 ]", + "EXPR [ (1, _54, _57) (-1, _66) 0 ]", + "EXPR [ (1, _60, _64) (1, _65, _66) -2 ]", "unconstrained func 0", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]", "unconstrained func 1", @@ -208,14 +162,14 @@ expression: artifact "unconstrained func 2", "[Const { destination: Direct(5), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(6), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(7), bit_size: Integer(U32), value: 3 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(7), offset_address: Direct(5) }, Cast { destination: Direct(1), source: Direct(1), bit_size: Integer(U32) }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(7), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(3), op: IntegerDiv, lhs: Direct(0), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Mul, lhs: Direct(3), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Sub, lhs: Direct(0), rhs: Direct(4) }, Store { destination_pointer: Direct(9), source: Direct(4) }, BinaryIntOp { destination: Direct(9), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(6) }, Mov { destination: Direct(0), source: Direct(3) }, BinaryIntOp { destination: Direct(8), op: LessThan, bit_size: U32, lhs: Direct(9), rhs: Direct(7) }, JumpIf { condition: Direct(8), location: 7 }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, Stop { return_data: HeapVector { pointer: Direct(9), size: Direct(1) } }]" ], - "debug_symbols": "pZhBbhsxDEXvMmsvhpRISrlKUQROMikMGE7g2gWKIHevlPmcJAuprbL6tCd64ZdISZ6X6WG5u/64PZwen35ON99eprvz4Xg8/Lg9Pt3vL4enU/n25XU3+cfby3lZylfTh+dl1PP+vJwu083pejzupl/74/Xtj34+709vetmfy9N5Ny2nh6IF+Hg4LjV63b2PnttDORsGhzluw+XzeGqPJ+UEAKlwi9DNQD0DHhkfwuYgNh3EjgOLDiAzGspgc6BDDmxzkJoOrOMgqSdAKc9DGTggziMOIrmDyO0q6gAoJwGB5zkPpbBZiEMWZLOgbQuhU8c0R7dAnIZS2CykIQvZW1FmaVrQjgXm7BZYwlAKPovCMjBeou9lEq1pIXcsBGG3UKp6JIXgcyBqI+OTJyCpWcjMHQtx2w9YZhpKgQDQoV7SsI0PI4WsLH8fz71ClLz1klIYSsEBqiOFqMkLUXPz/3OvEG32bmYb6gU1L0TjkU3dgq+CyUgVmPkUWmpWYejtiJm2TT1zM4XQOZxFeNsQJHzYFP+D8N6PpaoahO40BJ+GPLKMRFs7E7fbMaTO8cxG2x0pjewIVMrRkwjtIz727giU35Nob0uRvlwQkb+6nF0fvJVU4PYhEzs1Fd7PiCCqQ0n804pG/fpk2le7q09oLsf38mF/fzh/+sUzcTG8m0LZ3XZTnG7KNEptkd2kq9gqaZW8Cs1QgnKt6KKFQ2WdKEIFqlCDJmhelSuvTB5XXnHHlVf6j0O9fhaNUIFqvdMVtXqrKJrqKV0016Oq2JmhBGVo5RV+iFCBKtSgCZpXjTOUoAwFL4IXwYvgRfAieBE8AU/AE/AEPAFPwBPwBDwBT8BT8BQ8BU/BU/AUPAVPwVPwFDwDz8Az8Aw8A8/AM/AMPAPPwEvgpcor65pq1ZV1TAEaoQJVqEETNK+aZyhBwcvgZfAyeBm8DF4GL4NH8+wBecAeBA+iB+KBemAeJA+cTE4mJ5OTycnkZHIyOZmcTE4mJ9emCW/NV8m1+2rbrEElSw2iB+KBelDJWoPkQUZQ22cNKtBqEOuvoRqIB+qBeZDqz40aZAS1XeqOSbVf1iB4UIH1EvVrfz7s744LXr88Xk/3H97GXH4/+xN/X/N8frpfHq7npe5jb8/KzvYH", + "debug_symbols": "pZdBbuMwDEXv4nUWEkVSUq8yGBRu6hYBjCRwkwKDoncfqf5y04WEGWX1kjj84JdIWvoYnqen6+vj4fhyehsefn0MT8thng+vj/NpP14Op2P69eNzN5Svj5dlmtJPw83zFHUel+l4GR6O13neDe/jfP3609t5PH7xMi7pqdkN0/E5MQm+HOYpf/rcfUebeihFj2BneAuXn/G2Hm/VKASsOlNTaGZQBBxRR7xzmwOuOuCGA09SHHiOXRlsDrTLgd8chKoD33AQmIuDoKErg+KATY8DtsUBU72KGgI2qisWYvBdKWwWuMuCbBa0bsE16tgEggJZo10pbBZCl4UYEC9Gqha0YYFMWQQiZ7tSKAJC0hEvXGaZcLUKbGxYcK4okBPuScHFkoL2FKJsZSChOk2IGhZYykAi9rErBQsBNT3xuk1Eda5qQRoWxJeJRBL7UigC2rWLqmUX1Vd3kULDgsbNgrddFrS0o8aeoextGYne9RSil1KIXqr5u1YhRlMWkSJVC8E1hqIIbQ0t7mao/YfCdz9J5IpCcxlKM3jvOpbR2q0dra2/mlzjBe1IZTvj+J65aIlLMVkK1WOWa0xGZ8OWhI3VJNjcXRBs793Opg+yvC0mV19S3Kgp9z3jnah2JfFPO8py/2Lqvd3VVqhux+/0Zdwflh83loGS4d3g0kzbDTw8JAeS+2I36Aq/IqyIK6wBLUi5jBOTTt5My6CACnowgHElZb20tJT1Ut9R1kv9QS4fwxIZFFDzmSzR51NBYsiv1sSY53yyY0ALEuhABgVU0IMBhB5Dj6HH0GPoMfQYegw9hh5Dj6En0BPoCfQEegI9gZ5AT6An0BPoKfQUego9hZ5CT6GnWS+ts2a9tOUawLjSG9CCBDqQ8/UyUfLsSVTQ50tbYgDjymBAmxs0kUAHMph1Un4h5FN/YlwZDWhBykfqRAfK2ppRQQ/mPPKr8n1cDuPTPOGS/nI97m/u7Jc/5/Kk3OrPy2k/PV+XKXfL17PUP38B", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n if result {\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use super::{Eq, max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0_u64, 1), 0);\n assert_eq(min(0_u64, 0), 0);\n assert_eq(min(1_u64, 1), 1);\n assert_eq(min(255_u8, 0), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0_u64, 1), 1);\n assert_eq(max(0_u64, 0), 0);\n assert_eq(max(1_u64, 1), 1);\n assert_eq(max(255_u8, 0), 255);\n }\n\n #[test]\n fn correctly_handles_unequal_length_slices() {\n let slice_1 = &[0, 1, 2, 3];\n let slice_2 = &[0, 1, 2];\n assert(!slice_1.eq(slice_2));\n }\n}\n", "path": "std/cmp.nr" }, "50": { - "source": "use std::cmp::Ordering;\nuse std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Rem, Shl, Shr, Sub};\n\n// x = 3, y = 9\nfn main(x: u32, y: u32) {\n let wx = Wrapper::new(x);\n let wy = Wrapper::new(y);\n\n // expected x and expected y values\n let ex: u32 = 3;\n let ey: u32 = 9;\n\n assert((wx + wy).inner == ex + ey);\n assert((wy - wx).inner == ey - ex);\n assert((wx * wy).inner == ex * ey);\n assert((wx / wy).inner == ex / ey);\n assert((wx % wy).inner == ex % ey);\n\n assert((wx & wy).inner == (ex & ey));\n assert((wx | wy).inner == (ex | ey));\n assert((wx ^ wy).inner == (ex ^ ey));\n\n assert((wy << x as u8).inner == (ey << ex as u8));\n assert((wy >> x as u8).inner == (ey >> ex as u8));\n\n assert((wx == wy) == (ex == ey));\n assert((wx < wy) == (ex < ey));\n assert((wx <= wy) == (ex <= ey));\n assert((wx > wy) == (ex > ey));\n assert((wx >= wy) == (ex >= ey));\n assert(wx.cmp(wy) == ex.cmp(ey));\n\n // Ensure operator overloading still works with more complex types\n let pair_ascending = Pair { x: wx, y: wy };\n let pair_descending = Pair { x: wy, y: wx };\n\n assert(pair_ascending != pair_descending);\n\n assert(pair_ascending < pair_descending);\n assert(pair_ascending <= pair_descending);\n assert(pair_descending > pair_ascending);\n assert(pair_descending >= pair_ascending);\n\n assert(pair_ascending.cmp(pair_descending) == Ordering::less());\n}\n\nstruct Wrapper {\n inner: u32,\n}\n\nimpl Wrapper {\n fn new(inner: u32) -> Self {\n Wrapper { inner }\n }\n}\n\nimpl Add for Wrapper {\n fn add(self, other: Self) -> Self {\n Wrapper::new(self.inner + other.inner)\n }\n}\n\nimpl Sub for Wrapper {\n fn sub(self, other: Self) -> Self {\n Wrapper::new(self.inner - other.inner)\n }\n}\n\nimpl Mul for Wrapper {\n fn mul(self, other: Self) -> Self {\n Wrapper::new(self.inner * other.inner)\n }\n}\n\nimpl Div for Wrapper {\n fn div(self, other: Self) -> Self {\n Wrapper::new(self.inner / other.inner)\n }\n}\n\nimpl Rem for Wrapper {\n fn rem(self, other: Self) -> Self {\n Wrapper::new(self.inner % other.inner)\n }\n}\n\nimpl BitAnd for Wrapper {\n fn bitand(self, other: Self) -> Self {\n Wrapper::new(self.inner & other.inner)\n }\n}\n\nimpl BitOr for Wrapper {\n fn bitor(self, other: Self) -> Self {\n Wrapper::new(self.inner | other.inner)\n }\n}\n\nimpl BitXor for Wrapper {\n fn bitxor(self, other: Self) -> Self {\n Wrapper::new(self.inner ^ other.inner)\n }\n}\n\nimpl Shl for Wrapper {\n fn shl(self, other: u8) -> Self {\n Wrapper::new(self.inner << other)\n }\n}\n\nimpl Shr for Wrapper {\n fn shr(self, other: u8) -> Self {\n Wrapper::new(self.inner >> other)\n }\n}\n\nimpl Eq for Wrapper {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nimpl Ord for Wrapper {\n fn cmp(self, other: Self) -> Ordering {\n self.inner.cmp(other.inner)\n }\n}\n\nstruct Pair {\n x: Wrapper,\n y: Wrapper,\n}\n\nimpl Eq for Pair {\n fn eq(self, o: Self) -> bool {\n (self.x == o.x) & (self.y == o.y)\n }\n}\n\nimpl Ord for Pair {\n fn cmp(self, o: Self) -> Ordering {\n let mut result = self.x.cmp(o.x);\n\n if result == Ordering::equal() {\n result = self.y.cmp(o.y);\n }\n\n result\n }\n}\n", + "source": "use std::cmp::Ordering;\nuse std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Rem, Shl, Shr, Sub};\n\n// x = 3, y = 9\nfn main(x: u32, y: u32) {\n let wx = Wrapper::new(x);\n let wy = Wrapper::new(y);\n\n // expected x and expected y values\n let ex: u32 = 3;\n let ey: u32 = 9;\n\n assert((wx + wy).inner == ex + ey);\n assert((wy - wx).inner == ey - ex);\n assert((wx * wy).inner == ex * ey);\n assert((wx / wy).inner == ex / ey);\n assert((wx % wy).inner == ex % ey);\n\n assert((wx & wy).inner == (ex & ey));\n assert((wx | wy).inner == (ex | ey));\n assert((wx ^ wy).inner == (ex ^ ey));\n\n assert((wy << wx).inner == (ey << ex));\n assert((wy >> wx).inner == (ey >> ex));\n\n assert((wx == wy) == (ex == ey));\n assert((wx < wy) == (ex < ey));\n assert((wx <= wy) == (ex <= ey));\n assert((wx > wy) == (ex > ey));\n assert((wx >= wy) == (ex >= ey));\n assert(wx.cmp(wy) == ex.cmp(ey));\n\n // Ensure operator overloading still works with more complex types\n let pair_ascending = Pair { x: wx, y: wy };\n let pair_descending = Pair { x: wy, y: wx };\n\n assert(pair_ascending != pair_descending);\n\n assert(pair_ascending < pair_descending);\n assert(pair_ascending <= pair_descending);\n assert(pair_descending > pair_ascending);\n assert(pair_descending >= pair_ascending);\n\n assert(pair_ascending.cmp(pair_descending) == Ordering::less());\n}\n\nstruct Wrapper {\n inner: u32,\n}\n\nimpl Wrapper {\n fn new(inner: u32) -> Self {\n Wrapper { inner }\n }\n}\n\nimpl Add for Wrapper {\n fn add(self, other: Self) -> Self {\n Wrapper::new(self.inner + other.inner)\n }\n}\n\nimpl Sub for Wrapper {\n fn sub(self, other: Self) -> Self {\n Wrapper::new(self.inner - other.inner)\n }\n}\n\nimpl Mul for Wrapper {\n fn mul(self, other: Self) -> Self {\n Wrapper::new(self.inner * other.inner)\n }\n}\n\nimpl Div for Wrapper {\n fn div(self, other: Self) -> Self {\n Wrapper::new(self.inner / other.inner)\n }\n}\n\nimpl Rem for Wrapper {\n fn rem(self, other: Self) -> Self {\n Wrapper::new(self.inner % other.inner)\n }\n}\n\nimpl BitAnd for Wrapper {\n fn bitand(self, other: Self) -> Self {\n Wrapper::new(self.inner & other.inner)\n }\n}\n\nimpl BitOr for Wrapper {\n fn bitor(self, other: Self) -> Self {\n Wrapper::new(self.inner | other.inner)\n }\n}\n\nimpl BitXor for Wrapper {\n fn bitxor(self, other: Self) -> Self {\n Wrapper::new(self.inner ^ other.inner)\n }\n}\n\nimpl Shl for Wrapper {\n fn shl(self, other: Self) -> Self {\n Wrapper::new(self.inner << other.inner)\n }\n}\n\nimpl Shr for Wrapper {\n fn shr(self, other: Self) -> Self {\n Wrapper::new(self.inner >> other.inner)\n }\n}\n\nimpl Eq for Wrapper {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nimpl Ord for Wrapper {\n fn cmp(self, other: Self) -> Ordering {\n self.inner.cmp(other.inner)\n }\n}\n\nstruct Pair {\n x: Wrapper,\n y: Wrapper,\n}\n\nimpl Eq for Pair {\n fn eq(self, o: Self) -> bool {\n (self.x == o.x) & (self.y == o.y)\n }\n}\n\nimpl Ord for Pair {\n fn cmp(self, o: Self) -> Ordering {\n let mut result = self.x.cmp(o.x);\n\n if result == Ordering::equal() {\n result = self.y.cmp(o.y);\n }\n\n result\n }\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 1decc4a88d8..2958f0265d3 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -36,14 +36,14 @@ expression: artifact "error_kind": "string", "string": "attempt to add with overflow" }, - "5795655218219125583": { - "error_kind": "string", - "string": "Field failed to decompose into specified 8 limbs" - }, "7233212735005103307": { "error_kind": "string", "string": "attempt to multiply with overflow" }, + "10437400104653976995": { + "error_kind": "string", + "string": "Field failed to decompose into specified 6 limbs" + }, "14514982005979867414": { "error_kind": "string", "string": "attempt to bit-shift with overflow" @@ -52,7 +52,7 @@ expression: artifact }, "bytecode": [ "func 0", - "current witness index : _107", + "current witness index : _66", "private parameters indices : [_0, _1]", "public parameters indices : []", "return value indices : []", @@ -85,122 +85,76 @@ expression: artifact "EXPR [ (-1, _16) 4294967284 ]", "BLACKBOX::XOR [(_0, 32), (_1, 32)] [_17]", "EXPR [ (1, _17) -10 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 256 ]], outputs: [_18, _19]", - "BLACKBOX::RANGE [(_18, 24)] []", - "BLACKBOX::RANGE [(_19, 8)] []", - "EXPR [ (1, _0) (-256, _18) (-1, _19) 0 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _19) 224 ], EXPR [ 256 ]], outputs: [_20, _21]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) 4294967264 ], EXPR [ 4294967296 ]], outputs: [_18, _19]", + "BLACKBOX::RANGE [(_19, 32)] []", + "EXPR [ (1, _0) (-4294967296, _18) (-1, _19) 4294967264 ]", + "EXPR [ (-1, _18) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 6 ], EXPR [ 2 ]], outputs: [[_20, _21, _22, _23, _24, _25]]", "BLACKBOX::RANGE [(_20, 1)] []", - "BLACKBOX::RANGE [(_21, 8)] []", - "EXPR [ (1, _19) (-256, _20) (-1, _21) 224 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _19) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_22, _23, _24, _25, _26, _27, _28, _29]]", + "BLACKBOX::RANGE [(_21, 1)] []", "BLACKBOX::RANGE [(_22, 1)] []", "BLACKBOX::RANGE [(_23, 1)] []", "BLACKBOX::RANGE [(_24, 1)] []", "BLACKBOX::RANGE [(_25, 1)] []", - "BLACKBOX::RANGE [(_26, 1)] []", - "BLACKBOX::RANGE [(_27, 1)] []", - "BLACKBOX::RANGE [(_28, 1)] []", - "BLACKBOX::RANGE [(_29, 1)] []", - "EXPR [ (1, _19) (-1, _22) (-2, _23) (-4, _24) (-8, _25) (-16, _26) (-32, _27) (-64, _28) (-128, _29) 0 ]", - "EXPR [ (1, _29, _29) (2, _29) (-1, _30) 1 ]", - "EXPR [ (-1, _28) (-1, _31) 1 ]", - "EXPR [ (2, _28, _30) (1, _30, _31) (-1, _32) 0 ]", - "EXPR [ (1, _32, _32) (-1, _33) 0 ]", - "EXPR [ (-1, _27) (-1, _34) 1 ]", - "EXPR [ (2, _27, _33) (1, _33, _34) (-1, _35) 0 ]", - "EXPR [ (1, _35, _35) (-1, _36) 0 ]", - "EXPR [ (-1, _26) (-1, _37) 1 ]", - "EXPR [ (2, _26, _36) (1, _36, _37) (-1, _38) 0 ]", - "EXPR [ (1, _38, _38) (-1, _39) 0 ]", - "EXPR [ (-1, _25) (-1, _40) 1 ]", - "EXPR [ (2, _25, _39) (1, _39, _40) (-1, _41) 0 ]", - "EXPR [ (1, _41, _41) (-1, _42) 0 ]", - "EXPR [ (-1, _24) (-1, _43) 1 ]", - "EXPR [ (2, _24, _42) (1, _42, _43) (-1, _44) 0 ]", - "EXPR [ (1, _44, _44) (-1, _45) 0 ]", - "EXPR [ (-1, _23) (-1, _46) 1 ]", - "EXPR [ (2, _23, _45) (1, _45, _46) (-1, _47) 0 ]", - "EXPR [ (1, _47, _47) (-1, _48) 0 ]", - "EXPR [ (-1, _22) (-1, _49) 1 ]", - "EXPR [ (-1, _20) (-1, _50) 1 ]", - "EXPR [ (2, _22, _48) (1, _48, _49) (-1, _51) 0 ]", - "EXPR [ (1, _50, _51) (-1, _52) 0 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1, _52) 0 ], EXPR [ 4294967296 ]], outputs: [_53, _54]", - "BLACKBOX::RANGE [(_53, 222)] []", - "EXPR [ (1, _1, _52) (-4294967296, _53) (-1, _54) 0 ]", - "EXPR [ (-1, _53) (-1, _55) 5096253676302562286669017222071363378443840053029366383258766538131 ]", - "BLACKBOX::RANGE [(_55, 222)] []", - "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _53) 5096253676302562286669017222071363378443840053029366383258766538131 ]], outputs: [_56]", - "EXPR [ (-1, _53, _56) (5096253676302562286669017222071363378443840053029366383258766538131, _56) (1, _57) -1 ]", - "EXPR [ (-1, _53, _57) (5096253676302562286669017222071363378443840053029366383258766538131, _57) 0 ]", - "EXPR [ (1, _54, _57) (268435455, _57) (-1, _58) 0 ]", - "BLACKBOX::RANGE [(_58, 32)] []", - "EXPR [ (1, _50) -1 ]", - "EXPR [ (1, _54) -72 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _19) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_59, _60, _61, _62, _63, _64, _65, _66]]", - "BLACKBOX::RANGE [(_59, 1)] []", - "BLACKBOX::RANGE [(_60, 1)] []", - "BLACKBOX::RANGE [(_61, 1)] []", - "BLACKBOX::RANGE [(_62, 1)] []", - "BLACKBOX::RANGE [(_63, 1)] []", - "BLACKBOX::RANGE [(_64, 1)] []", - "BLACKBOX::RANGE [(_65, 1)] []", - "BLACKBOX::RANGE [(_66, 1)] []", - "EXPR [ (1, _19) (-1, _59) (-2, _60) (-4, _61) (-8, _62) (-16, _63) (-32, _64) (-64, _65) (-128, _66) 0 ]", - "EXPR [ (1, _66, _66) (2, _66) (-1, _67) 1 ]", - "EXPR [ (-1, _65) (-1, _68) 1 ]", - "EXPR [ (2, _65, _67) (1, _67, _68) (-1, _69) 0 ]", - "EXPR [ (1, _69, _69) (-1, _70) 0 ]", - "EXPR [ (-1, _64) (-1, _71) 1 ]", - "EXPR [ (2, _64, _70) (1, _70, _71) (-1, _72) 0 ]", - "EXPR [ (1, _72, _72) (-1, _73) 0 ]", - "EXPR [ (-1, _63) (-1, _74) 1 ]", - "EXPR [ (2, _63, _73) (1, _73, _74) (-1, _75) 0 ]", - "EXPR [ (1, _75, _75) (-1, _76) 0 ]", - "EXPR [ (-1, _62) (-1, _77) 1 ]", - "EXPR [ (2, _62, _76) (1, _76, _77) (-1, _78) 0 ]", - "EXPR [ (1, _78, _78) (-1, _79) 0 ]", - "EXPR [ (-1, _61) (-1, _80) 1 ]", - "EXPR [ (2, _61, _79) (1, _79, _80) (-1, _81) 0 ]", - "EXPR [ (1, _81, _81) (-1, _82) 0 ]", - "EXPR [ (-1, _60) (-1, _83) 1 ]", - "EXPR [ (2, _60, _82) (1, _82, _83) (-1, _84) 0 ]", - "EXPR [ (1, _84, _84) (-1, _85) 0 ]", - "EXPR [ (-1, _59) (-1, _86) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _85, _59) (1, _85, _86) 0 ]], outputs: [_87]", - "EXPR [ (2, _59, _85) (1, _85, _86) (-1, _88) 0 ]", - "EXPR [ (1, _87, _88) -1 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1) 0 ], EXPR [ (1, _88) 0 ]], outputs: [_89, _90]", - "BLACKBOX::RANGE [(_90, 32)] []", - "EXPR [ (1, _88) (-1, _90) (-1, _91) -1 ]", - "BLACKBOX::RANGE [(_91, 32)] []", - "EXPR [ (-1, _88, _89) (1, _1) (-1, _90) 0 ]", - "EXPR [ (1, _89) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) (-1, _1) 0 ]], outputs: [_92]", - "EXPR [ (1, _0, _92) (-1, _1, _92) -1 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) (-1, _1) 4294967296 ], EXPR [ 4294967296 ]], outputs: [_93, _94]", - "BLACKBOX::RANGE [(_93, 1)] []", - "BLACKBOX::RANGE [(_94, 32)] []", - "EXPR [ (1, _0) (-1, _1) (-4294967296, _93) (-1, _94) 4294967296 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _0) (1, _1) 4294967296 ], EXPR [ 4294967296 ]], outputs: [_95, _96]", - "BLACKBOX::RANGE [(_95, 1)] []", - "BLACKBOX::RANGE [(_96, 32)] []", - "EXPR [ (-1, _0) (1, _1) (-4294967296, _95) (-1, _96) 4294967296 ]", - "EXPR [ (-1, _93, _95) (2, _93) (-1, _97) 0 ]", - "EXPR [ (1, _93, _97) 0 ]", - "EXPR [ (-1, _93, _95) (2, _95) (-1, _98) 0 ]", - "EXPR [ (1, _95, _98) (-1, _99) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _99) 0 ]], outputs: [_100]", - "EXPR [ (1, _99, _100) (1, _101) -1 ]", - "EXPR [ (1, _99, _101) 0 ]", - "EXPR [ (1, _93, _101) (-1, _102) 0 ]", - "EXPR [ (-1, _95) (-1, _103) 1 ]", - "EXPR [ (1, _95, _102) (2, _102, _103) (-1, _104) 0 ]", - "EXPR [ (1, _102, _104) (-1, _105) 0 ]", - "EXPR [ (-1, _101) (-1, _106) 1 ]", - "EXPR [ (1, _95, _98) (-1, _107) 0 ]", - "EXPR [ (1, _101, _105) (1, _106, _107) -2 ]", + "EXPR [ (1, _0) (-1, _20) (-2, _21) (-4, _22) (-8, _23) (-16, _24) (-32, _25) 0 ]", + "EXPR [ (1, _25, _25) (2, _25) (-1, _26) 1 ]", + "EXPR [ (-1, _24) (-1, _27) 1 ]", + "EXPR [ (2, _24, _26) (1, _26, _27) (-1, _28) 0 ]", + "EXPR [ (1, _28, _28) (-1, _29) 0 ]", + "EXPR [ (-1, _23) (-1, _30) 1 ]", + "EXPR [ (2, _23, _29) (1, _29, _30) (-1, _31) 0 ]", + "EXPR [ (1, _31, _31) (-1, _32) 0 ]", + "EXPR [ (-1, _22) (-1, _33) 1 ]", + "EXPR [ (2, _22, _32) (1, _32, _33) (-1, _34) 0 ]", + "EXPR [ (1, _34, _34) (-1, _35) 0 ]", + "EXPR [ (-1, _21) (-1, _36) 1 ]", + "EXPR [ (2, _21, _35) (1, _35, _36) (-1, _37) 0 ]", + "EXPR [ (1, _37, _37) (-1, _38) 0 ]", + "EXPR [ (-1, _20) (-1, _39) 1 ]", + "EXPR [ (2, _20, _38) (1, _38, _39) (-1, _40) 0 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1, _40) 0 ], EXPR [ 4294967296 ]], outputs: [_41, _42]", + "BLACKBOX::RANGE [(_41, 222)] []", + "EXPR [ (1, _1, _40) (-4294967296, _41) (-1, _42) 0 ]", + "EXPR [ (-1, _41) (-1, _43) 5096253676302562286669017222071363378443840053029366383258766538131 ]", + "BLACKBOX::RANGE [(_43, 222)] []", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _41) 5096253676302562286669017222071363378443840053029366383258766538131 ]], outputs: [_44]", + "EXPR [ (-1, _41, _44) (5096253676302562286669017222071363378443840053029366383258766538131, _44) (1, _45) -1 ]", + "EXPR [ (-1, _41, _45) (5096253676302562286669017222071363378443840053029366383258766538131, _45) 0 ]", + "EXPR [ (1, _42, _45) (268435455, _45) (-1, _46) 0 ]", + "BLACKBOX::RANGE [(_46, 32)] []", + "EXPR [ (1, _42) -72 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _40) 0 ]], outputs: [_47]", + "EXPR [ (1, _40, _47) -1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1) 0 ], EXPR [ (1, _40) 0 ]], outputs: [_48, _49]", + "BLACKBOX::RANGE [(_49, 32)] []", + "EXPR [ (1, _40) (-1, _49) (-1, _50) -1 ]", + "BLACKBOX::RANGE [(_50, 32)] []", + "EXPR [ (-1, _40, _48) (1, _1) (-1, _49) 0 ]", + "EXPR [ (1, _48) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) (-1, _1) 0 ]], outputs: [_51]", + "EXPR [ (1, _0, _51) (-1, _1, _51) -1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) (-1, _1) 4294967296 ], EXPR [ 4294967296 ]], outputs: [_52, _53]", + "BLACKBOX::RANGE [(_52, 1)] []", + "BLACKBOX::RANGE [(_53, 32)] []", + "EXPR [ (1, _0) (-1, _1) (-4294967296, _52) (-1, _53) 4294967296 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _0) (1, _1) 4294967296 ], EXPR [ 4294967296 ]], outputs: [_54, _55]", + "BLACKBOX::RANGE [(_54, 1)] []", + "BLACKBOX::RANGE [(_55, 32)] []", + "EXPR [ (-1, _0) (1, _1) (-4294967296, _54) (-1, _55) 4294967296 ]", + "EXPR [ (-1, _52, _54) (2, _52) (-1, _56) 0 ]", + "EXPR [ (1, _52, _56) 0 ]", + "EXPR [ (-1, _52, _54) (2, _54) (-1, _57) 0 ]", + "EXPR [ (1, _54, _57) (-1, _58) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _58) 0 ]], outputs: [_59]", + "EXPR [ (1, _58, _59) (1, _60) -1 ]", + "EXPR [ (1, _58, _60) 0 ]", + "EXPR [ (1, _52, _60) (-1, _61) 0 ]", + "EXPR [ (-1, _54) (-1, _62) 1 ]", + "EXPR [ (1, _54, _61) (2, _61, _62) (-1, _63) 0 ]", + "EXPR [ (1, _61, _63) (-1, _64) 0 ]", + "EXPR [ (-1, _60) (-1, _65) 1 ]", + "EXPR [ (1, _54, _57) (-1, _66) 0 ]", + "EXPR [ (1, _60, _64) (1, _65, _66) -2 ]", "unconstrained func 0", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]", "unconstrained func 1", @@ -208,14 +162,14 @@ expression: artifact "unconstrained func 2", "[Const { destination: Direct(5), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(6), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(7), bit_size: Integer(U32), value: 3 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(7), offset_address: Direct(5) }, Cast { destination: Direct(1), source: Direct(1), bit_size: Integer(U32) }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(7), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(3), op: IntegerDiv, lhs: Direct(0), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Mul, lhs: Direct(3), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Sub, lhs: Direct(0), rhs: Direct(4) }, Store { destination_pointer: Direct(9), source: Direct(4) }, BinaryIntOp { destination: Direct(9), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(6) }, Mov { destination: Direct(0), source: Direct(3) }, BinaryIntOp { destination: Direct(8), op: LessThan, bit_size: U32, lhs: Direct(9), rhs: Direct(7) }, JumpIf { condition: Direct(8), location: 7 }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, Stop { return_data: HeapVector { pointer: Direct(9), size: Direct(1) } }]" ], - "debug_symbols": "pZhBbhsxDEXvMmsvhpRISrlKUQROMikMGE7g2gWKIHevlPmcJAuprbL6tCd64ZdISZ6X6WG5u/64PZwen35ON99eprvz4Xg8/Lg9Pt3vL4enU/n25XU3+cfby3lZylfTh+dl1PP+vJwu083pejzupl/74/Xtj34+709vetmfy9N5Ny2nh6IF+Hg4LjV63b2PnttDORsGhzluw+XzeGqPJ+UEAKlwi9DNQD0DHhkfwuYgNh3EjgOLDiAzGspgc6BDDmxzkJoOrOMgqSdAKc9DGTggziMOIrmDyO0q6gAoJwGB5zkPpbBZiEMWZLOgbQuhU8c0R7dAnIZS2CykIQvZW1FmaVrQjgXm7BZYwlAKPovCMjBeou9lEq1pIXcsBGG3UKp6JIXgcyBqI+OTJyCpWcjMHQtx2w9YZhpKgQDQoV7SsI0PI4WsLH8fz71ClLz1klIYSsEBqiOFqMkLUXPz/3OvEG32bmYb6gU1L0TjkU3dgq+CyUgVmPkUWmpWYejtiJm2TT1zM4XQOZxFeNsQJHzYFP+D8N6PpaoahO40BJ+GPLKMRFs7E7fbMaTO8cxG2x0pjewIVMrRkwjtIz727giU35Nob0uRvlwQkb+6nF0fvJVU4PYhEzs1Fd7PiCCqQ0n804pG/fpk2le7q09oLsf38mF/fzh/+sUzcTG8m0LZ3XZTnG7KNEptkd2kq9gqaZW8Cs1QgnKt6KKFQ2WdKEIFqlCDJmhelSuvTB5XXnHHlVf6j0O9fhaNUIFqvdMVtXqrKJrqKV0016Oq2JmhBGVo5RV+iFCBKtSgCZpXjTOUoAwFL4IXwYvgRfAieBE8AU/AE/AEPAFPwBPwBDwBT8BT8BQ8BU/BU/AUPAVPwVPwFDwDz8Az8Aw8A8/AM/AMPAPPwEvgpcor65pq1ZV1TAEaoQJVqEETNK+aZyhBwcvgZfAyeBm8DF4GL4NH8+wBecAeBA+iB+KBemAeJA+cTE4mJ5OTycnkZHIyOZmcTE4mJ9emCW/NV8m1+2rbrEElSw2iB+KBelDJWoPkQUZQ22cNKtBqEOuvoRqIB+qBeZDqz40aZAS1XeqOSbVf1iB4UIH1EvVrfz7s744LXr88Xk/3H97GXH4/+xN/X/N8frpfHq7npe5jb8/KzvYH", + "debug_symbols": "pZdBbuMwDEXv4nUWEkVSUq8yGBRu6hYBjCRwkwKDoncfqf5y04WEGWX1kjj84JdIWvoYnqen6+vj4fhyehsefn0MT8thng+vj/NpP14Op2P69eNzN5Svj5dlmtJPw83zFHUel+l4GR6O13neDe/jfP3609t5PH7xMi7pqdkN0/E5MQm+HOYpf/rcfUebeihFj2BneAuXn/G2Hm/VKASsOlNTaGZQBBxRR7xzmwOuOuCGA09SHHiOXRlsDrTLgd8chKoD33AQmIuDoKErg+KATY8DtsUBU72KGgI2qisWYvBdKWwWuMuCbBa0bsE16tgEggJZo10pbBZCl4UYEC9Gqha0YYFMWQQiZ7tSKAJC0hEvXGaZcLUKbGxYcK4okBPuScHFkoL2FKJsZSChOk2IGhZYykAi9rErBQsBNT3xuk1Eda5qQRoWxJeJRBL7UigC2rWLqmUX1Vd3kULDgsbNgrddFrS0o8aeoextGYne9RSil1KIXqr5u1YhRlMWkSJVC8E1hqIIbQ0t7mao/YfCdz9J5IpCcxlKM3jvOpbR2q0dra2/mlzjBe1IZTvj+J65aIlLMVkK1WOWa0xGZ8OWhI3VJNjcXRBs793Opg+yvC0mV19S3Kgp9z3jnah2JfFPO8py/2Lqvd3VVqhux+/0Zdwflh83loGS4d3g0kzbDTw8JAeS+2I36Aq/IqyIK6wBLUi5jBOTTt5My6CACnowgHElZb20tJT1Ut9R1kv9QS4fwxIZFFDzmSzR51NBYsiv1sSY53yyY0ALEuhABgVU0IMBhB5Dj6HH0GPoMfQYegw9hh5Dj6En0BPoCfQEegI9gZ5AT6An0BPoKfQUego9hZ5CT6GnWS+ts2a9tOUawLjSG9CCBDqQ8/UyUfLsSVTQ50tbYgDjymBAmxs0kUAHMph1Un4h5FN/YlwZDWhBykfqRAfK2ppRQQ/mPPKr8n1cDuPTPOGS/nI97m/u7Jc/5/Kk3OrPy2k/PV+XKXfL17PUP38B", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n if result {\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use super::{Eq, max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0_u64, 1), 0);\n assert_eq(min(0_u64, 0), 0);\n assert_eq(min(1_u64, 1), 1);\n assert_eq(min(255_u8, 0), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0_u64, 1), 1);\n assert_eq(max(0_u64, 0), 0);\n assert_eq(max(1_u64, 1), 1);\n assert_eq(max(255_u8, 0), 255);\n }\n\n #[test]\n fn correctly_handles_unequal_length_slices() {\n let slice_1 = &[0, 1, 2, 3];\n let slice_2 = &[0, 1, 2];\n assert(!slice_1.eq(slice_2));\n }\n}\n", "path": "std/cmp.nr" }, "50": { - "source": "use std::cmp::Ordering;\nuse std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Rem, Shl, Shr, Sub};\n\n// x = 3, y = 9\nfn main(x: u32, y: u32) {\n let wx = Wrapper::new(x);\n let wy = Wrapper::new(y);\n\n // expected x and expected y values\n let ex: u32 = 3;\n let ey: u32 = 9;\n\n assert((wx + wy).inner == ex + ey);\n assert((wy - wx).inner == ey - ex);\n assert((wx * wy).inner == ex * ey);\n assert((wx / wy).inner == ex / ey);\n assert((wx % wy).inner == ex % ey);\n\n assert((wx & wy).inner == (ex & ey));\n assert((wx | wy).inner == (ex | ey));\n assert((wx ^ wy).inner == (ex ^ ey));\n\n assert((wy << x as u8).inner == (ey << ex as u8));\n assert((wy >> x as u8).inner == (ey >> ex as u8));\n\n assert((wx == wy) == (ex == ey));\n assert((wx < wy) == (ex < ey));\n assert((wx <= wy) == (ex <= ey));\n assert((wx > wy) == (ex > ey));\n assert((wx >= wy) == (ex >= ey));\n assert(wx.cmp(wy) == ex.cmp(ey));\n\n // Ensure operator overloading still works with more complex types\n let pair_ascending = Pair { x: wx, y: wy };\n let pair_descending = Pair { x: wy, y: wx };\n\n assert(pair_ascending != pair_descending);\n\n assert(pair_ascending < pair_descending);\n assert(pair_ascending <= pair_descending);\n assert(pair_descending > pair_ascending);\n assert(pair_descending >= pair_ascending);\n\n assert(pair_ascending.cmp(pair_descending) == Ordering::less());\n}\n\nstruct Wrapper {\n inner: u32,\n}\n\nimpl Wrapper {\n fn new(inner: u32) -> Self {\n Wrapper { inner }\n }\n}\n\nimpl Add for Wrapper {\n fn add(self, other: Self) -> Self {\n Wrapper::new(self.inner + other.inner)\n }\n}\n\nimpl Sub for Wrapper {\n fn sub(self, other: Self) -> Self {\n Wrapper::new(self.inner - other.inner)\n }\n}\n\nimpl Mul for Wrapper {\n fn mul(self, other: Self) -> Self {\n Wrapper::new(self.inner * other.inner)\n }\n}\n\nimpl Div for Wrapper {\n fn div(self, other: Self) -> Self {\n Wrapper::new(self.inner / other.inner)\n }\n}\n\nimpl Rem for Wrapper {\n fn rem(self, other: Self) -> Self {\n Wrapper::new(self.inner % other.inner)\n }\n}\n\nimpl BitAnd for Wrapper {\n fn bitand(self, other: Self) -> Self {\n Wrapper::new(self.inner & other.inner)\n }\n}\n\nimpl BitOr for Wrapper {\n fn bitor(self, other: Self) -> Self {\n Wrapper::new(self.inner | other.inner)\n }\n}\n\nimpl BitXor for Wrapper {\n fn bitxor(self, other: Self) -> Self {\n Wrapper::new(self.inner ^ other.inner)\n }\n}\n\nimpl Shl for Wrapper {\n fn shl(self, other: u8) -> Self {\n Wrapper::new(self.inner << other)\n }\n}\n\nimpl Shr for Wrapper {\n fn shr(self, other: u8) -> Self {\n Wrapper::new(self.inner >> other)\n }\n}\n\nimpl Eq for Wrapper {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nimpl Ord for Wrapper {\n fn cmp(self, other: Self) -> Ordering {\n self.inner.cmp(other.inner)\n }\n}\n\nstruct Pair {\n x: Wrapper,\n y: Wrapper,\n}\n\nimpl Eq for Pair {\n fn eq(self, o: Self) -> bool {\n (self.x == o.x) & (self.y == o.y)\n }\n}\n\nimpl Ord for Pair {\n fn cmp(self, o: Self) -> Ordering {\n let mut result = self.x.cmp(o.x);\n\n if result == Ordering::equal() {\n result = self.y.cmp(o.y);\n }\n\n result\n }\n}\n", + "source": "use std::cmp::Ordering;\nuse std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Rem, Shl, Shr, Sub};\n\n// x = 3, y = 9\nfn main(x: u32, y: u32) {\n let wx = Wrapper::new(x);\n let wy = Wrapper::new(y);\n\n // expected x and expected y values\n let ex: u32 = 3;\n let ey: u32 = 9;\n\n assert((wx + wy).inner == ex + ey);\n assert((wy - wx).inner == ey - ex);\n assert((wx * wy).inner == ex * ey);\n assert((wx / wy).inner == ex / ey);\n assert((wx % wy).inner == ex % ey);\n\n assert((wx & wy).inner == (ex & ey));\n assert((wx | wy).inner == (ex | ey));\n assert((wx ^ wy).inner == (ex ^ ey));\n\n assert((wy << wx).inner == (ey << ex));\n assert((wy >> wx).inner == (ey >> ex));\n\n assert((wx == wy) == (ex == ey));\n assert((wx < wy) == (ex < ey));\n assert((wx <= wy) == (ex <= ey));\n assert((wx > wy) == (ex > ey));\n assert((wx >= wy) == (ex >= ey));\n assert(wx.cmp(wy) == ex.cmp(ey));\n\n // Ensure operator overloading still works with more complex types\n let pair_ascending = Pair { x: wx, y: wy };\n let pair_descending = Pair { x: wy, y: wx };\n\n assert(pair_ascending != pair_descending);\n\n assert(pair_ascending < pair_descending);\n assert(pair_ascending <= pair_descending);\n assert(pair_descending > pair_ascending);\n assert(pair_descending >= pair_ascending);\n\n assert(pair_ascending.cmp(pair_descending) == Ordering::less());\n}\n\nstruct Wrapper {\n inner: u32,\n}\n\nimpl Wrapper {\n fn new(inner: u32) -> Self {\n Wrapper { inner }\n }\n}\n\nimpl Add for Wrapper {\n fn add(self, other: Self) -> Self {\n Wrapper::new(self.inner + other.inner)\n }\n}\n\nimpl Sub for Wrapper {\n fn sub(self, other: Self) -> Self {\n Wrapper::new(self.inner - other.inner)\n }\n}\n\nimpl Mul for Wrapper {\n fn mul(self, other: Self) -> Self {\n Wrapper::new(self.inner * other.inner)\n }\n}\n\nimpl Div for Wrapper {\n fn div(self, other: Self) -> Self {\n Wrapper::new(self.inner / other.inner)\n }\n}\n\nimpl Rem for Wrapper {\n fn rem(self, other: Self) -> Self {\n Wrapper::new(self.inner % other.inner)\n }\n}\n\nimpl BitAnd for Wrapper {\n fn bitand(self, other: Self) -> Self {\n Wrapper::new(self.inner & other.inner)\n }\n}\n\nimpl BitOr for Wrapper {\n fn bitor(self, other: Self) -> Self {\n Wrapper::new(self.inner | other.inner)\n }\n}\n\nimpl BitXor for Wrapper {\n fn bitxor(self, other: Self) -> Self {\n Wrapper::new(self.inner ^ other.inner)\n }\n}\n\nimpl Shl for Wrapper {\n fn shl(self, other: Self) -> Self {\n Wrapper::new(self.inner << other.inner)\n }\n}\n\nimpl Shr for Wrapper {\n fn shr(self, other: Self) -> Self {\n Wrapper::new(self.inner >> other.inner)\n }\n}\n\nimpl Eq for Wrapper {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nimpl Ord for Wrapper {\n fn cmp(self, other: Self) -> Ordering {\n self.inner.cmp(other.inner)\n }\n}\n\nstruct Pair {\n x: Wrapper,\n y: Wrapper,\n}\n\nimpl Eq for Pair {\n fn eq(self, o: Self) -> bool {\n (self.x == o.x) & (self.y == o.y)\n }\n}\n\nimpl Ord for Pair {\n fn cmp(self, o: Self) -> Ordering {\n let mut result = self.x.cmp(o.x);\n\n if result == Ordering::equal() {\n result = self.y.cmp(o.y);\n }\n\n result\n }\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 50b52cb9443..54f51cbcf09 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -58,16 +58,16 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32837), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32837) }, Mov { destination: Relative(2), source: Direct(32838) }, Call { location: 15 }, Call { location: 18 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Field, value: 0 }, Const { destination: Direct(32836), bit_size: Field, value: 2 }, Return, Call { location: 161 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 23 }, Call { location: 167 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 28 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 32 }, Call { location: 170 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 37 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 45 }, BinaryIntOp { destination: Relative(7), op: Div, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 45 }, Call { location: 173 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 50 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Div, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 56 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Mul, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 64 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: And, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 70 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(3), op: Or, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 76 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(3), op: Xor, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 82 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Cast { destination: Relative(6), source: Relative(1), bit_size: Integer(U8) }, Cast { destination: Relative(3), source: Relative(6), bit_size: Integer(U32) }, Cast { destination: Relative(6), source: Relative(3), bit_size: Integer(U8) }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(8), location: 91 }, Call { location: 176 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 72 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, JumpIf { condition: Relative(8), location: 96 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 101 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 107 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(1) }, Mov { destination: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 179 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(7) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(3), rhs: Direct(32835) }, JumpIf { condition: Relative(5), location: 119 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Const { destination: Relative(3), bit_size: Integer(U32), value: 9 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 7 }, Mov { destination: Relative(7), source: Direct(0) }, Mov { destination: Relative(8), source: Relative(4) }, Mov { destination: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(6) }, Call { location: 179 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(5), source: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Direct(32835), rhs: Relative(5) }, JumpIf { condition: Relative(3), location: 132 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Relative(2) }, Mov { destination: Relative(8), source: Relative(2) }, Mov { destination: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 195 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 146 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(2) }, Mov { destination: Relative(7), source: Relative(1) }, Mov { destination: Relative(8), source: Relative(1) }, Mov { destination: Relative(9), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 195 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(3), rhs: Direct(32836) }, JumpIf { condition: Relative(1), location: 160 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 166 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 161 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 191 }, Jump { location: 183 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(1), source: Relative(4), bit_size: U1 }, Cast { destination: Relative(2), source: Relative(4), bit_size: Field }, Cast { destination: Relative(4), source: Relative(1), bit_size: Field }, BinaryFieldOp { destination: Relative(1), op: Mul, lhs: Relative(2), rhs: Direct(32836) }, BinaryFieldOp { destination: Relative(2), op: Add, lhs: Relative(1), rhs: Relative(4) }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 193 }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 193 }, Mov { destination: Relative(1), source: Relative(3) }, Return, Call { location: 161 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 7 }, Mov { destination: Relative(7), source: Direct(0) }, Mov { destination: Relative(8), source: Relative(1) }, Mov { destination: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(6) }, Call { location: 179 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(5), source: Relative(8) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(5) }, Const { destination: Relative(3), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 211 }, Jump { location: 221 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(2) }, Mov { destination: Relative(8), source: Relative(4) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 179 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(7) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 221 }, Load { destination: Relative(2), source_pointer: Relative(1) }, Mov { destination: Relative(1), source: Relative(2) }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32837), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32837) }, Mov { destination: Relative(2), source: Direct(32838) }, Call { location: 15 }, Call { location: 18 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Field, value: 0 }, Const { destination: Direct(32836), bit_size: Field, value: 2 }, Return, Call { location: 158 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 23 }, Call { location: 164 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 28 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 32 }, Call { location: 167 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 37 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 45 }, BinaryIntOp { destination: Relative(7), op: Div, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 45 }, Call { location: 170 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 50 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Div, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 56 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Mul, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 64 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: And, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 70 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(3), op: Or, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 76 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(3), op: Xor, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 82 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 87 }, Call { location: 173 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 72 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 93 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 98 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 104 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(1) }, Mov { destination: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 176 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(7) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(3), rhs: Direct(32835) }, JumpIf { condition: Relative(5), location: 116 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Const { destination: Relative(3), bit_size: Integer(U32), value: 9 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 7 }, Mov { destination: Relative(7), source: Direct(0) }, Mov { destination: Relative(8), source: Relative(4) }, Mov { destination: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(6) }, Call { location: 176 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(5), source: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Direct(32835), rhs: Relative(5) }, JumpIf { condition: Relative(3), location: 129 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Relative(2) }, Mov { destination: Relative(8), source: Relative(2) }, Mov { destination: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 192 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 143 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(2) }, Mov { destination: Relative(7), source: Relative(1) }, Mov { destination: Relative(8), source: Relative(1) }, Mov { destination: Relative(9), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 192 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(3), rhs: Direct(32836) }, JumpIf { condition: Relative(1), location: 157 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 163 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 158 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 188 }, Jump { location: 180 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(1), source: Relative(4), bit_size: U1 }, Cast { destination: Relative(2), source: Relative(4), bit_size: Field }, Cast { destination: Relative(4), source: Relative(1), bit_size: Field }, BinaryFieldOp { destination: Relative(1), op: Mul, lhs: Relative(2), rhs: Direct(32836) }, BinaryFieldOp { destination: Relative(2), op: Add, lhs: Relative(1), rhs: Relative(4) }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 190 }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 190 }, Mov { destination: Relative(1), source: Relative(3) }, Return, Call { location: 158 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 7 }, Mov { destination: Relative(7), source: Direct(0) }, Mov { destination: Relative(8), source: Relative(1) }, Mov { destination: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(6) }, Call { location: 176 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(5), source: Relative(8) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(5) }, Const { destination: Relative(3), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 208 }, Jump { location: 218 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(2) }, Mov { destination: Relative(8), source: Relative(4) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 176 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(7) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 218 }, Load { destination: Relative(2), source_pointer: Relative(1) }, Mov { destination: Relative(1), source: Relative(2) }, Return]" ], - "debug_symbols": "tZjdbho9EIbvZY85sMcz/uFWqigiCamQEIkofNKniHvvDJ53kx7strXUkzwPpX6ZWcZe4GN62T9dvz8eTq9vP6btt4/p6Xw4Hg/fH49vz7vL4e2k//oxBfsT27SlzUShI3ZQR5q2ScEd0pE7SkedtqJod6TQETs0JStSB3dIR+7QlKqoHe0ODh2xgzpSB3doSlPkjtJRO9odoikxKjUmajNCzuRkpzg1K7KyOKtT46J2k4MzOsmZnJZXlJanJebsLM7qbJ3FrnhQ2iXXOgs5k5Od4tQ80iteNI+0rlKdrbMGZ3RantZVk5Odlqd11uwszupsnS04LU/rbeRMTnaK0+ZC+2k2GFpvq87WGUOAaGJKJhqZ2CRBGCKQDLHcbFIhzSUGSIQQJEEYYsnFJEMKpEIsWXuKti26RAhBEoQhAsmQArHkZtJcbKt0iRBN5mCSIAwRSIYUSIU0F9s+XSIEyYxkRjIj2bYS27tjm6lLhTQX21JdIoQgCcIQgSBZkCxIFiTb8DKZWI7Nho3rXWyuWEwKpEJaF7LR6hIhBEkQC2QTgWSIJReT6mKDxM2EIAnCEIFkSIFUiFVY7UC1wHq7bSYcwY+X835vJ/CXM1lP6vfdeX+6TNvT9XjcTP/tjtf7f/rxvjvdedmd9Vl9x/anF6UGvh6Oe7Pb5nN1WF5KrfjiFHheLr+uj8vrY7bdfg+IWWgpYbWCjApoZH1Kcwe82AGvdFAYAbGUOFTB3EEe6qDMHdTFDspKBzWjgFhbGKoAARxGOuCIDpiWp2glQHexeIJu3zZUwtwCD7Ugcwt5uYW0Msd6u0ILesIPlTC3UIdaaNiKEmSxhbzSAlFDCyRpqARcRSEZWC+Ms0y4LLbQVlpIQmhBp3qkhIRrILmMrK8oQOriIBOttMDzeUAS4lAJ0QPy0F7KaV6fRgY5k/x+Pa0NorR5L+WYhkpAQM4jg5grBjG3xdentUEsAbuZytBeyAWDWGjkUC/zbaks3xjT2iDWMB/KNY2VgIAiI4NYCt7FUhc3gr3G8oeLOLfQaKyEhBLayLvY5kvQeGQvN4rz+pHX1+8z88cbGjoN9HsL9oJ+Txm5MYnQfKxL+pLw5wGfh6oeDX8fkGKL86fM5TOV+V+Okn6+DXMRy7c3XjkY0+fdKUnOAxeCyueFWN5T9i1l5EI86KPd8+H8y09LN8s6H3ZPx70/fL2enr88e/n/Hc/gp6n389vz/uV63lvSl9+n9O+3mOMm5vxgX83toY5nLPRws5f/CQ==", + "debug_symbols": "tZjRTiM5EEX/pZ95sKtcLptfGY1QgDCKFAWUgZVWiH/fKly3YR66tWtpXzgnBF+qHNvdnffl8Xj/9uvudHl6/r3c/nhf7q+n8/n06+78/HB4PT1f7LfvS/IfuS+3dLNQGsgDNMDLLRvKgAzUAR1oy60Y+ic4DeQBS6kGHigDMlAHLKUZ2kD/REkDeYAGeKAMWEo31AEdaAP9E2IpORstJlszQkEOlqAELSsXowZb0OKydVNTMAcpyEHPU6PnWYm1BjXYgn1QfcaT0afc6lQKcrAEJWh5ZDOulkdWl7ZgH2wpmIOeZ1PcOFiCEqxBDXqe1d/6YE/BHKSg59n8dl8VVn+XYA1q0PLY5rVbHlvdOSVIhhCEIR4qLgKpEIU0SA/JCZIhnlxdGFIgAvFkdVFIg/QQ3xZDMoQgDCkQT24uFaKQBvFkm73sW2VIhhCEIQUikApRSIMguSC5ILkg2TdRSS4FIpAKUUiD9BDfUkMyhCBIFiQLkgXJvnKLreTsS7WQSw7xRVWKS4EIpEIU0iB9CPnSGuKBfiz50hrCEE+uLgLxnObSQ3whDckQgjCkQATiFaqLB+rHx82Cc/bu9Xo8+jH77eC14/jlcD1eXpfby9v5fLP8dTi/ff7R75fD5ZOvh6u9a3N2vDwaLfDpdD66fdx8jU7bQ6lrDOZU1uHy5/i8PT7XVCMgV05bCbsVIICJJsYzrx2UzQ7KTgdKgg609KkK1g7qVAe6dtA2O9CdDpov6dFBq22qAnRQ0kwHJaODQturaCfANi+jhd50qoS1hTLVgqwt1O0WeGcdp0aRYMdDnSphbaFNtdBbjJckmy3UnRYoYRKIOE+VgAAhmRgvBWeZlM1VkPtOC8xIIJYyU4JfAEcJdWYhyroMpG2eJkQ7LRTBgURF+1QJOQJqmhlf1xOxMm+2IDstiOJEIulzJSCgTn2KteJTrLr5KVLbaaH2tQXNUy1UbMfaZw5lzShAty+MvHNtJu2YBGpUpkrAqaw8sxdUsBdUNqeQy97NQVpb6MRTJWAvqM6M7+sU9KlV0NbPYK5+ewxZb0/y1JXRnjuwEO3xYuYWTYTWY1n421r89wFfh6L08t8DODfMAtsd/+ZtHv+fS4lp3ZFMZfPyWHYORv66urDUOjERVNeJIN2eCJ2biJ/26vBwuv7x/c+HZ11Ph/vzMV4+vV0evr37+vcL3sH3Ry/X54fj49v16EnfvkSynz+ytBt7WPjpz8/+sqq97D8//N//Aw==", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n if result {\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use super::{Eq, max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0_u64, 1), 0);\n assert_eq(min(0_u64, 0), 0);\n assert_eq(min(1_u64, 1), 1);\n assert_eq(min(255_u8, 0), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0_u64, 1), 1);\n assert_eq(max(0_u64, 0), 0);\n assert_eq(max(1_u64, 1), 1);\n assert_eq(max(255_u8, 0), 255);\n }\n\n #[test]\n fn correctly_handles_unequal_length_slices() {\n let slice_1 = &[0, 1, 2, 3];\n let slice_2 = &[0, 1, 2];\n assert(!slice_1.eq(slice_2));\n }\n}\n", "path": "std/cmp.nr" }, "50": { - "source": "use std::cmp::Ordering;\nuse std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Rem, Shl, Shr, Sub};\n\n// x = 3, y = 9\nfn main(x: u32, y: u32) {\n let wx = Wrapper::new(x);\n let wy = Wrapper::new(y);\n\n // expected x and expected y values\n let ex: u32 = 3;\n let ey: u32 = 9;\n\n assert((wx + wy).inner == ex + ey);\n assert((wy - wx).inner == ey - ex);\n assert((wx * wy).inner == ex * ey);\n assert((wx / wy).inner == ex / ey);\n assert((wx % wy).inner == ex % ey);\n\n assert((wx & wy).inner == (ex & ey));\n assert((wx | wy).inner == (ex | ey));\n assert((wx ^ wy).inner == (ex ^ ey));\n\n assert((wy << x as u8).inner == (ey << ex as u8));\n assert((wy >> x as u8).inner == (ey >> ex as u8));\n\n assert((wx == wy) == (ex == ey));\n assert((wx < wy) == (ex < ey));\n assert((wx <= wy) == (ex <= ey));\n assert((wx > wy) == (ex > ey));\n assert((wx >= wy) == (ex >= ey));\n assert(wx.cmp(wy) == ex.cmp(ey));\n\n // Ensure operator overloading still works with more complex types\n let pair_ascending = Pair { x: wx, y: wy };\n let pair_descending = Pair { x: wy, y: wx };\n\n assert(pair_ascending != pair_descending);\n\n assert(pair_ascending < pair_descending);\n assert(pair_ascending <= pair_descending);\n assert(pair_descending > pair_ascending);\n assert(pair_descending >= pair_ascending);\n\n assert(pair_ascending.cmp(pair_descending) == Ordering::less());\n}\n\nstruct Wrapper {\n inner: u32,\n}\n\nimpl Wrapper {\n fn new(inner: u32) -> Self {\n Wrapper { inner }\n }\n}\n\nimpl Add for Wrapper {\n fn add(self, other: Self) -> Self {\n Wrapper::new(self.inner + other.inner)\n }\n}\n\nimpl Sub for Wrapper {\n fn sub(self, other: Self) -> Self {\n Wrapper::new(self.inner - other.inner)\n }\n}\n\nimpl Mul for Wrapper {\n fn mul(self, other: Self) -> Self {\n Wrapper::new(self.inner * other.inner)\n }\n}\n\nimpl Div for Wrapper {\n fn div(self, other: Self) -> Self {\n Wrapper::new(self.inner / other.inner)\n }\n}\n\nimpl Rem for Wrapper {\n fn rem(self, other: Self) -> Self {\n Wrapper::new(self.inner % other.inner)\n }\n}\n\nimpl BitAnd for Wrapper {\n fn bitand(self, other: Self) -> Self {\n Wrapper::new(self.inner & other.inner)\n }\n}\n\nimpl BitOr for Wrapper {\n fn bitor(self, other: Self) -> Self {\n Wrapper::new(self.inner | other.inner)\n }\n}\n\nimpl BitXor for Wrapper {\n fn bitxor(self, other: Self) -> Self {\n Wrapper::new(self.inner ^ other.inner)\n }\n}\n\nimpl Shl for Wrapper {\n fn shl(self, other: u8) -> Self {\n Wrapper::new(self.inner << other)\n }\n}\n\nimpl Shr for Wrapper {\n fn shr(self, other: u8) -> Self {\n Wrapper::new(self.inner >> other)\n }\n}\n\nimpl Eq for Wrapper {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nimpl Ord for Wrapper {\n fn cmp(self, other: Self) -> Ordering {\n self.inner.cmp(other.inner)\n }\n}\n\nstruct Pair {\n x: Wrapper,\n y: Wrapper,\n}\n\nimpl Eq for Pair {\n fn eq(self, o: Self) -> bool {\n (self.x == o.x) & (self.y == o.y)\n }\n}\n\nimpl Ord for Pair {\n fn cmp(self, o: Self) -> Ordering {\n let mut result = self.x.cmp(o.x);\n\n if result == Ordering::equal() {\n result = self.y.cmp(o.y);\n }\n\n result\n }\n}\n", + "source": "use std::cmp::Ordering;\nuse std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Rem, Shl, Shr, Sub};\n\n// x = 3, y = 9\nfn main(x: u32, y: u32) {\n let wx = Wrapper::new(x);\n let wy = Wrapper::new(y);\n\n // expected x and expected y values\n let ex: u32 = 3;\n let ey: u32 = 9;\n\n assert((wx + wy).inner == ex + ey);\n assert((wy - wx).inner == ey - ex);\n assert((wx * wy).inner == ex * ey);\n assert((wx / wy).inner == ex / ey);\n assert((wx % wy).inner == ex % ey);\n\n assert((wx & wy).inner == (ex & ey));\n assert((wx | wy).inner == (ex | ey));\n assert((wx ^ wy).inner == (ex ^ ey));\n\n assert((wy << wx).inner == (ey << ex));\n assert((wy >> wx).inner == (ey >> ex));\n\n assert((wx == wy) == (ex == ey));\n assert((wx < wy) == (ex < ey));\n assert((wx <= wy) == (ex <= ey));\n assert((wx > wy) == (ex > ey));\n assert((wx >= wy) == (ex >= ey));\n assert(wx.cmp(wy) == ex.cmp(ey));\n\n // Ensure operator overloading still works with more complex types\n let pair_ascending = Pair { x: wx, y: wy };\n let pair_descending = Pair { x: wy, y: wx };\n\n assert(pair_ascending != pair_descending);\n\n assert(pair_ascending < pair_descending);\n assert(pair_ascending <= pair_descending);\n assert(pair_descending > pair_ascending);\n assert(pair_descending >= pair_ascending);\n\n assert(pair_ascending.cmp(pair_descending) == Ordering::less());\n}\n\nstruct Wrapper {\n inner: u32,\n}\n\nimpl Wrapper {\n fn new(inner: u32) -> Self {\n Wrapper { inner }\n }\n}\n\nimpl Add for Wrapper {\n fn add(self, other: Self) -> Self {\n Wrapper::new(self.inner + other.inner)\n }\n}\n\nimpl Sub for Wrapper {\n fn sub(self, other: Self) -> Self {\n Wrapper::new(self.inner - other.inner)\n }\n}\n\nimpl Mul for Wrapper {\n fn mul(self, other: Self) -> Self {\n Wrapper::new(self.inner * other.inner)\n }\n}\n\nimpl Div for Wrapper {\n fn div(self, other: Self) -> Self {\n Wrapper::new(self.inner / other.inner)\n }\n}\n\nimpl Rem for Wrapper {\n fn rem(self, other: Self) -> Self {\n Wrapper::new(self.inner % other.inner)\n }\n}\n\nimpl BitAnd for Wrapper {\n fn bitand(self, other: Self) -> Self {\n Wrapper::new(self.inner & other.inner)\n }\n}\n\nimpl BitOr for Wrapper {\n fn bitor(self, other: Self) -> Self {\n Wrapper::new(self.inner | other.inner)\n }\n}\n\nimpl BitXor for Wrapper {\n fn bitxor(self, other: Self) -> Self {\n Wrapper::new(self.inner ^ other.inner)\n }\n}\n\nimpl Shl for Wrapper {\n fn shl(self, other: Self) -> Self {\n Wrapper::new(self.inner << other.inner)\n }\n}\n\nimpl Shr for Wrapper {\n fn shr(self, other: Self) -> Self {\n Wrapper::new(self.inner >> other.inner)\n }\n}\n\nimpl Eq for Wrapper {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nimpl Ord for Wrapper {\n fn cmp(self, other: Self) -> Ordering {\n self.inner.cmp(other.inner)\n }\n}\n\nstruct Pair {\n x: Wrapper,\n y: Wrapper,\n}\n\nimpl Eq for Pair {\n fn eq(self, o: Self) -> bool {\n (self.x == o.x) & (self.y == o.y)\n }\n}\n\nimpl Ord for Pair {\n fn cmp(self, o: Self) -> Ordering {\n let mut result = self.x.cmp(o.x);\n\n if result == Ordering::equal() {\n result = self.y.cmp(o.y);\n }\n\n result\n }\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_true_inliner_0.snap index 50b52cb9443..54f51cbcf09 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_true_inliner_0.snap @@ -58,16 +58,16 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32837), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32837) }, Mov { destination: Relative(2), source: Direct(32838) }, Call { location: 15 }, Call { location: 18 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Field, value: 0 }, Const { destination: Direct(32836), bit_size: Field, value: 2 }, Return, Call { location: 161 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 23 }, Call { location: 167 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 28 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 32 }, Call { location: 170 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 37 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 45 }, BinaryIntOp { destination: Relative(7), op: Div, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 45 }, Call { location: 173 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 50 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Div, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 56 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Mul, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 64 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: And, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 70 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(3), op: Or, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 76 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(3), op: Xor, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 82 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Cast { destination: Relative(6), source: Relative(1), bit_size: Integer(U8) }, Cast { destination: Relative(3), source: Relative(6), bit_size: Integer(U32) }, Cast { destination: Relative(6), source: Relative(3), bit_size: Integer(U8) }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(8), location: 91 }, Call { location: 176 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 72 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, JumpIf { condition: Relative(8), location: 96 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 101 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 107 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(1) }, Mov { destination: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 179 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(7) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(3), rhs: Direct(32835) }, JumpIf { condition: Relative(5), location: 119 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Const { destination: Relative(3), bit_size: Integer(U32), value: 9 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 7 }, Mov { destination: Relative(7), source: Direct(0) }, Mov { destination: Relative(8), source: Relative(4) }, Mov { destination: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(6) }, Call { location: 179 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(5), source: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Direct(32835), rhs: Relative(5) }, JumpIf { condition: Relative(3), location: 132 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Relative(2) }, Mov { destination: Relative(8), source: Relative(2) }, Mov { destination: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 195 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 146 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(2) }, Mov { destination: Relative(7), source: Relative(1) }, Mov { destination: Relative(8), source: Relative(1) }, Mov { destination: Relative(9), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 195 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(3), rhs: Direct(32836) }, JumpIf { condition: Relative(1), location: 160 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 166 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 161 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 191 }, Jump { location: 183 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(1), source: Relative(4), bit_size: U1 }, Cast { destination: Relative(2), source: Relative(4), bit_size: Field }, Cast { destination: Relative(4), source: Relative(1), bit_size: Field }, BinaryFieldOp { destination: Relative(1), op: Mul, lhs: Relative(2), rhs: Direct(32836) }, BinaryFieldOp { destination: Relative(2), op: Add, lhs: Relative(1), rhs: Relative(4) }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 193 }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 193 }, Mov { destination: Relative(1), source: Relative(3) }, Return, Call { location: 161 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 7 }, Mov { destination: Relative(7), source: Direct(0) }, Mov { destination: Relative(8), source: Relative(1) }, Mov { destination: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(6) }, Call { location: 179 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(5), source: Relative(8) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(5) }, Const { destination: Relative(3), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 211 }, Jump { location: 221 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(2) }, Mov { destination: Relative(8), source: Relative(4) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 179 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(7) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 221 }, Load { destination: Relative(2), source_pointer: Relative(1) }, Mov { destination: Relative(1), source: Relative(2) }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32837), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32837) }, Mov { destination: Relative(2), source: Direct(32838) }, Call { location: 15 }, Call { location: 18 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Field, value: 0 }, Const { destination: Direct(32836), bit_size: Field, value: 2 }, Return, Call { location: 158 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 23 }, Call { location: 164 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 28 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 32 }, Call { location: 167 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 37 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 45 }, BinaryIntOp { destination: Relative(7), op: Div, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 45 }, Call { location: 170 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 50 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Div, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 56 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Mul, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 64 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: And, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 70 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(3), op: Or, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 76 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(3), op: Xor, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 82 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 87 }, Call { location: 173 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 72 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 93 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 98 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 104 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(1) }, Mov { destination: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 176 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(7) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(3), rhs: Direct(32835) }, JumpIf { condition: Relative(5), location: 116 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Const { destination: Relative(3), bit_size: Integer(U32), value: 9 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 7 }, Mov { destination: Relative(7), source: Direct(0) }, Mov { destination: Relative(8), source: Relative(4) }, Mov { destination: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(6) }, Call { location: 176 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(5), source: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Direct(32835), rhs: Relative(5) }, JumpIf { condition: Relative(3), location: 129 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Relative(2) }, Mov { destination: Relative(8), source: Relative(2) }, Mov { destination: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 192 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 143 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(2) }, Mov { destination: Relative(7), source: Relative(1) }, Mov { destination: Relative(8), source: Relative(1) }, Mov { destination: Relative(9), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 192 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(3), rhs: Direct(32836) }, JumpIf { condition: Relative(1), location: 157 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 163 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 158 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 188 }, Jump { location: 180 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(1), source: Relative(4), bit_size: U1 }, Cast { destination: Relative(2), source: Relative(4), bit_size: Field }, Cast { destination: Relative(4), source: Relative(1), bit_size: Field }, BinaryFieldOp { destination: Relative(1), op: Mul, lhs: Relative(2), rhs: Direct(32836) }, BinaryFieldOp { destination: Relative(2), op: Add, lhs: Relative(1), rhs: Relative(4) }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 190 }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 190 }, Mov { destination: Relative(1), source: Relative(3) }, Return, Call { location: 158 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 7 }, Mov { destination: Relative(7), source: Direct(0) }, Mov { destination: Relative(8), source: Relative(1) }, Mov { destination: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(6) }, Call { location: 176 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(5), source: Relative(8) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(5) }, Const { destination: Relative(3), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 208 }, Jump { location: 218 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(2) }, Mov { destination: Relative(8), source: Relative(4) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 176 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(7) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 218 }, Load { destination: Relative(2), source_pointer: Relative(1) }, Mov { destination: Relative(1), source: Relative(2) }, Return]" ], - "debug_symbols": "tZjdbho9EIbvZY85sMcz/uFWqigiCamQEIkofNKniHvvDJ53kx7strXUkzwPpX6ZWcZe4GN62T9dvz8eTq9vP6btt4/p6Xw4Hg/fH49vz7vL4e2k//oxBfsT27SlzUShI3ZQR5q2ScEd0pE7SkedtqJod6TQETs0JStSB3dIR+7QlKqoHe0ODh2xgzpSB3doSlPkjtJRO9odoikxKjUmajNCzuRkpzg1K7KyOKtT46J2k4MzOsmZnJZXlJanJebsLM7qbJ3FrnhQ2iXXOgs5k5Od4tQ80iteNI+0rlKdrbMGZ3RantZVk5Odlqd11uwszupsnS04LU/rbeRMTnaK0+ZC+2k2GFpvq87WGUOAaGJKJhqZ2CRBGCKQDLHcbFIhzSUGSIQQJEEYYsnFJEMKpEIsWXuKti26RAhBEoQhAsmQArHkZtJcbKt0iRBN5mCSIAwRSIYUSIU0F9s+XSIEyYxkRjIj2bYS27tjm6lLhTQX21JdIoQgCcIQgSBZkCxIFiTb8DKZWI7Nho3rXWyuWEwKpEJaF7LR6hIhBEkQC2QTgWSIJReT6mKDxM2EIAnCEIFkSIFUiFVY7UC1wHq7bSYcwY+X835vJ/CXM1lP6vfdeX+6TNvT9XjcTP/tjtf7f/rxvjvdedmd9Vl9x/anF6UGvh6Oe7Pb5nN1WF5KrfjiFHheLr+uj8vrY7bdfg+IWWgpYbWCjApoZH1Kcwe82AGvdFAYAbGUOFTB3EEe6qDMHdTFDspKBzWjgFhbGKoAARxGOuCIDpiWp2glQHexeIJu3zZUwtwCD7Ugcwt5uYW0Msd6u0ILesIPlTC3UIdaaNiKEmSxhbzSAlFDCyRpqARcRSEZWC+Ms0y4LLbQVlpIQmhBp3qkhIRrILmMrK8oQOriIBOttMDzeUAS4lAJ0QPy0F7KaV6fRgY5k/x+Pa0NorR5L+WYhkpAQM4jg5grBjG3xdentUEsAbuZytBeyAWDWGjkUC/zbaks3xjT2iDWMB/KNY2VgIAiI4NYCt7FUhc3gr3G8oeLOLfQaKyEhBLayLvY5kvQeGQvN4rz+pHX1+8z88cbGjoN9HsL9oJ+Txm5MYnQfKxL+pLw5wGfh6oeDX8fkGKL86fM5TOV+V+Okn6+DXMRy7c3XjkY0+fdKUnOAxeCyueFWN5T9i1l5EI86KPd8+H8y09LN8s6H3ZPx70/fL2enr88e/n/Hc/gp6n389vz/uV63lvSl9+n9O+3mOMm5vxgX83toY5nLPRws5f/CQ==", + "debug_symbols": "tZjRTiM5EEX/pZ95sKtcLptfGY1QgDCKFAWUgZVWiH/fKly3YR66tWtpXzgnBF+qHNvdnffl8Xj/9uvudHl6/r3c/nhf7q+n8/n06+78/HB4PT1f7LfvS/IfuS+3dLNQGsgDNMDLLRvKgAzUAR1oy60Y+ic4DeQBS6kGHigDMlAHLKUZ2kD/REkDeYAGeKAMWEo31AEdaAP9E2IpORstJlszQkEOlqAELSsXowZb0OKydVNTMAcpyEHPU6PnWYm1BjXYgn1QfcaT0afc6lQKcrAEJWh5ZDOulkdWl7ZgH2wpmIOeZ1PcOFiCEqxBDXqe1d/6YE/BHKSg59n8dl8VVn+XYA1q0PLY5rVbHlvdOSVIhhCEIR4qLgKpEIU0SA/JCZIhnlxdGFIgAvFkdVFIg/QQ3xZDMoQgDCkQT24uFaKQBvFkm73sW2VIhhCEIQUikApRSIMguSC5ILkg2TdRSS4FIpAKUUiD9BDfUkMyhCBIFiQLkgXJvnKLreTsS7WQSw7xRVWKS4EIpEIU0iB9CPnSGuKBfiz50hrCEE+uLgLxnObSQ3whDckQgjCkQATiFaqLB+rHx82Cc/bu9Xo8+jH77eC14/jlcD1eXpfby9v5fLP8dTi/ff7R75fD5ZOvh6u9a3N2vDwaLfDpdD66fdx8jU7bQ6lrDOZU1uHy5/i8PT7XVCMgV05bCbsVIICJJsYzrx2UzQ7KTgdKgg609KkK1g7qVAe6dtA2O9CdDpov6dFBq22qAnRQ0kwHJaODQturaCfANi+jhd50qoS1hTLVgqwt1O0WeGcdp0aRYMdDnSphbaFNtdBbjJckmy3UnRYoYRKIOE+VgAAhmRgvBWeZlM1VkPtOC8xIIJYyU4JfAEcJdWYhyroMpG2eJkQ7LRTBgURF+1QJOQJqmhlf1xOxMm+2IDstiOJEIulzJSCgTn2KteJTrLr5KVLbaaH2tQXNUy1UbMfaZw5lzShAty+MvHNtJu2YBGpUpkrAqaw8sxdUsBdUNqeQy97NQVpb6MRTJWAvqM6M7+sU9KlV0NbPYK5+ewxZb0/y1JXRnjuwEO3xYuYWTYTWY1n421r89wFfh6L08t8DODfMAtsd/+ZtHv+fS4lp3ZFMZfPyWHYORv66urDUOjERVNeJIN2eCJ2biJ/26vBwuv7x/c+HZ11Ph/vzMV4+vV0evr37+vcL3sH3Ry/X54fj49v16EnfvkSynz+ytBt7WPjpz8/+sqq97D8//N//Aw==", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n if result {\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use super::{Eq, max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0_u64, 1), 0);\n assert_eq(min(0_u64, 0), 0);\n assert_eq(min(1_u64, 1), 1);\n assert_eq(min(255_u8, 0), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0_u64, 1), 1);\n assert_eq(max(0_u64, 0), 0);\n assert_eq(max(1_u64, 1), 1);\n assert_eq(max(255_u8, 0), 255);\n }\n\n #[test]\n fn correctly_handles_unequal_length_slices() {\n let slice_1 = &[0, 1, 2, 3];\n let slice_2 = &[0, 1, 2];\n assert(!slice_1.eq(slice_2));\n }\n}\n", "path": "std/cmp.nr" }, "50": { - "source": "use std::cmp::Ordering;\nuse std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Rem, Shl, Shr, Sub};\n\n// x = 3, y = 9\nfn main(x: u32, y: u32) {\n let wx = Wrapper::new(x);\n let wy = Wrapper::new(y);\n\n // expected x and expected y values\n let ex: u32 = 3;\n let ey: u32 = 9;\n\n assert((wx + wy).inner == ex + ey);\n assert((wy - wx).inner == ey - ex);\n assert((wx * wy).inner == ex * ey);\n assert((wx / wy).inner == ex / ey);\n assert((wx % wy).inner == ex % ey);\n\n assert((wx & wy).inner == (ex & ey));\n assert((wx | wy).inner == (ex | ey));\n assert((wx ^ wy).inner == (ex ^ ey));\n\n assert((wy << x as u8).inner == (ey << ex as u8));\n assert((wy >> x as u8).inner == (ey >> ex as u8));\n\n assert((wx == wy) == (ex == ey));\n assert((wx < wy) == (ex < ey));\n assert((wx <= wy) == (ex <= ey));\n assert((wx > wy) == (ex > ey));\n assert((wx >= wy) == (ex >= ey));\n assert(wx.cmp(wy) == ex.cmp(ey));\n\n // Ensure operator overloading still works with more complex types\n let pair_ascending = Pair { x: wx, y: wy };\n let pair_descending = Pair { x: wy, y: wx };\n\n assert(pair_ascending != pair_descending);\n\n assert(pair_ascending < pair_descending);\n assert(pair_ascending <= pair_descending);\n assert(pair_descending > pair_ascending);\n assert(pair_descending >= pair_ascending);\n\n assert(pair_ascending.cmp(pair_descending) == Ordering::less());\n}\n\nstruct Wrapper {\n inner: u32,\n}\n\nimpl Wrapper {\n fn new(inner: u32) -> Self {\n Wrapper { inner }\n }\n}\n\nimpl Add for Wrapper {\n fn add(self, other: Self) -> Self {\n Wrapper::new(self.inner + other.inner)\n }\n}\n\nimpl Sub for Wrapper {\n fn sub(self, other: Self) -> Self {\n Wrapper::new(self.inner - other.inner)\n }\n}\n\nimpl Mul for Wrapper {\n fn mul(self, other: Self) -> Self {\n Wrapper::new(self.inner * other.inner)\n }\n}\n\nimpl Div for Wrapper {\n fn div(self, other: Self) -> Self {\n Wrapper::new(self.inner / other.inner)\n }\n}\n\nimpl Rem for Wrapper {\n fn rem(self, other: Self) -> Self {\n Wrapper::new(self.inner % other.inner)\n }\n}\n\nimpl BitAnd for Wrapper {\n fn bitand(self, other: Self) -> Self {\n Wrapper::new(self.inner & other.inner)\n }\n}\n\nimpl BitOr for Wrapper {\n fn bitor(self, other: Self) -> Self {\n Wrapper::new(self.inner | other.inner)\n }\n}\n\nimpl BitXor for Wrapper {\n fn bitxor(self, other: Self) -> Self {\n Wrapper::new(self.inner ^ other.inner)\n }\n}\n\nimpl Shl for Wrapper {\n fn shl(self, other: u8) -> Self {\n Wrapper::new(self.inner << other)\n }\n}\n\nimpl Shr for Wrapper {\n fn shr(self, other: u8) -> Self {\n Wrapper::new(self.inner >> other)\n }\n}\n\nimpl Eq for Wrapper {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nimpl Ord for Wrapper {\n fn cmp(self, other: Self) -> Ordering {\n self.inner.cmp(other.inner)\n }\n}\n\nstruct Pair {\n x: Wrapper,\n y: Wrapper,\n}\n\nimpl Eq for Pair {\n fn eq(self, o: Self) -> bool {\n (self.x == o.x) & (self.y == o.y)\n }\n}\n\nimpl Ord for Pair {\n fn cmp(self, o: Self) -> Ordering {\n let mut result = self.x.cmp(o.x);\n\n if result == Ordering::equal() {\n result = self.y.cmp(o.y);\n }\n\n result\n }\n}\n", + "source": "use std::cmp::Ordering;\nuse std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Rem, Shl, Shr, Sub};\n\n// x = 3, y = 9\nfn main(x: u32, y: u32) {\n let wx = Wrapper::new(x);\n let wy = Wrapper::new(y);\n\n // expected x and expected y values\n let ex: u32 = 3;\n let ey: u32 = 9;\n\n assert((wx + wy).inner == ex + ey);\n assert((wy - wx).inner == ey - ex);\n assert((wx * wy).inner == ex * ey);\n assert((wx / wy).inner == ex / ey);\n assert((wx % wy).inner == ex % ey);\n\n assert((wx & wy).inner == (ex & ey));\n assert((wx | wy).inner == (ex | ey));\n assert((wx ^ wy).inner == (ex ^ ey));\n\n assert((wy << wx).inner == (ey << ex));\n assert((wy >> wx).inner == (ey >> ex));\n\n assert((wx == wy) == (ex == ey));\n assert((wx < wy) == (ex < ey));\n assert((wx <= wy) == (ex <= ey));\n assert((wx > wy) == (ex > ey));\n assert((wx >= wy) == (ex >= ey));\n assert(wx.cmp(wy) == ex.cmp(ey));\n\n // Ensure operator overloading still works with more complex types\n let pair_ascending = Pair { x: wx, y: wy };\n let pair_descending = Pair { x: wy, y: wx };\n\n assert(pair_ascending != pair_descending);\n\n assert(pair_ascending < pair_descending);\n assert(pair_ascending <= pair_descending);\n assert(pair_descending > pair_ascending);\n assert(pair_descending >= pair_ascending);\n\n assert(pair_ascending.cmp(pair_descending) == Ordering::less());\n}\n\nstruct Wrapper {\n inner: u32,\n}\n\nimpl Wrapper {\n fn new(inner: u32) -> Self {\n Wrapper { inner }\n }\n}\n\nimpl Add for Wrapper {\n fn add(self, other: Self) -> Self {\n Wrapper::new(self.inner + other.inner)\n }\n}\n\nimpl Sub for Wrapper {\n fn sub(self, other: Self) -> Self {\n Wrapper::new(self.inner - other.inner)\n }\n}\n\nimpl Mul for Wrapper {\n fn mul(self, other: Self) -> Self {\n Wrapper::new(self.inner * other.inner)\n }\n}\n\nimpl Div for Wrapper {\n fn div(self, other: Self) -> Self {\n Wrapper::new(self.inner / other.inner)\n }\n}\n\nimpl Rem for Wrapper {\n fn rem(self, other: Self) -> Self {\n Wrapper::new(self.inner % other.inner)\n }\n}\n\nimpl BitAnd for Wrapper {\n fn bitand(self, other: Self) -> Self {\n Wrapper::new(self.inner & other.inner)\n }\n}\n\nimpl BitOr for Wrapper {\n fn bitor(self, other: Self) -> Self {\n Wrapper::new(self.inner | other.inner)\n }\n}\n\nimpl BitXor for Wrapper {\n fn bitxor(self, other: Self) -> Self {\n Wrapper::new(self.inner ^ other.inner)\n }\n}\n\nimpl Shl for Wrapper {\n fn shl(self, other: Self) -> Self {\n Wrapper::new(self.inner << other.inner)\n }\n}\n\nimpl Shr for Wrapper {\n fn shr(self, other: Self) -> Self {\n Wrapper::new(self.inner >> other.inner)\n }\n}\n\nimpl Eq for Wrapper {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nimpl Ord for Wrapper {\n fn cmp(self, other: Self) -> Ordering {\n self.inner.cmp(other.inner)\n }\n}\n\nstruct Pair {\n x: Wrapper,\n y: Wrapper,\n}\n\nimpl Eq for Pair {\n fn eq(self, o: Self) -> bool {\n (self.x == o.x) & (self.y == o.y)\n }\n}\n\nimpl Ord for Pair {\n fn cmp(self, o: Self) -> Ordering {\n let mut result = self.x.cmp(o.x);\n\n if result == Ordering::equal() {\n result = self.y.cmp(o.y);\n }\n\n result\n }\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 2c109a4212a..193a2531009 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/binary_operator_overloading/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -58,16 +58,16 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 15 }, Call { location: 16 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 365 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 21 }, Call { location: 371 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 26 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 30 }, Call { location: 374 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 35 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 43 }, BinaryIntOp { destination: Relative(8), op: Div, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 43 }, Call { location: 377 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 48 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 54 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 62 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: And, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 68 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 74 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: Xor, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 80 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Cast { destination: Relative(6), source: Relative(1), bit_size: Integer(U8) }, Cast { destination: Relative(4), source: Relative(6), bit_size: Integer(U32) }, Cast { destination: Relative(6), source: Relative(4), bit_size: Integer(U8) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(8), location: 89 }, Call { location: 380 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 72 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(7) }, JumpIf { condition: Relative(8), location: 94 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 99 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 105 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(1), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(2), source: Relative(6), bit_size: Field }, Not { destination: Relative(7), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(8), source: Relative(6), bit_size: Field }, Not { destination: Relative(9), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(10), source: Relative(6), bit_size: Field }, Not { destination: Relative(11), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(12), source: Relative(6), bit_size: Field }, Not { destination: Relative(13), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(14), source: Relative(6), bit_size: Field }, Not { destination: Relative(15), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(16), source: Relative(6), bit_size: Field }, Not { destination: Relative(17), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(18), source: Relative(6), bit_size: Field }, Not { destination: Relative(19), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(20), source: Relative(6), bit_size: Field }, Not { destination: Relative(21), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(22), source: Relative(6), bit_size: Field }, Const { destination: Relative(23), bit_size: Field, value: 0 }, Const { destination: Relative(24), bit_size: Field, value: 2 }, JumpIf { condition: Relative(4), location: 136 }, Jump { location: 129 }, Not { destination: Relative(25), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Cast { destination: Relative(27), source: Relative(25), bit_size: Field }, BinaryFieldOp { destination: Relative(25), op: Mul, lhs: Relative(26), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(26), op: Add, lhs: Relative(25), rhs: Relative(27) }, Mov { destination: Relative(3), source: Relative(26) }, Jump { location: 138 }, Mov { destination: Relative(3), source: Relative(23) }, Jump { location: 138 }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(3), rhs: Relative(23) }, JumpIf { condition: Relative(26), location: 142 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, JumpIf { condition: Relative(4), location: 149 }, Jump { location: 144 }, Cast { destination: Relative(3), source: Relative(1), bit_size: Field }, BinaryFieldOp { destination: Relative(1), op: Mul, lhs: Relative(2), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(2), op: Add, lhs: Relative(1), rhs: Relative(3) }, Mov { destination: Relative(25), source: Relative(2) }, Jump { location: 151 }, Mov { destination: Relative(25), source: Relative(23) }, Jump { location: 151 }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(25), rhs: Relative(24) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(3), location: 156 }, Const { destination: Relative(25), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(25) } }, JumpIf { condition: Relative(4), location: 163 }, Jump { location: 158 }, Cast { destination: Relative(2), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(8), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(7), op: Add, lhs: Relative(3), rhs: Relative(2) }, Mov { destination: Relative(1), source: Relative(7) }, Jump { location: 165 }, Mov { destination: Relative(1), source: Relative(23) }, Jump { location: 165 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(24) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 170 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, JumpIf { condition: Relative(4), location: 177 }, Jump { location: 172 }, Cast { destination: Relative(1), source: Relative(9), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(10), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(7), op: Add, lhs: Relative(3), rhs: Relative(1) }, Mov { destination: Relative(2), source: Relative(7) }, Jump { location: 179 }, Mov { destination: Relative(2), source: Relative(23) }, Jump { location: 179 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(23) }, JumpIf { condition: Relative(3), location: 183 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, JumpIf { condition: Relative(4), location: 190 }, Jump { location: 185 }, Cast { destination: Relative(2), source: Relative(11), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(12), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(7), op: Add, lhs: Relative(3), rhs: Relative(2) }, Mov { destination: Relative(1), source: Relative(7) }, Jump { location: 192 }, Mov { destination: Relative(1), source: Relative(23) }, Jump { location: 192 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(23) }, JumpIf { condition: Relative(3), location: 196 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, JumpIf { condition: Relative(4), location: 203 }, Jump { location: 198 }, Cast { destination: Relative(1), source: Relative(13), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(14), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(7), op: Add, lhs: Relative(3), rhs: Relative(1) }, Mov { destination: Relative(2), source: Relative(7) }, Jump { location: 205 }, Mov { destination: Relative(2), source: Relative(23) }, Jump { location: 205 }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, Const { destination: Relative(3), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(3) }, Not { destination: Relative(2), source: Relative(4), bit_size: U1 }, Cast { destination: Relative(8), source: Relative(4), bit_size: Field }, Not { destination: Relative(9), source: Relative(4), bit_size: U1 }, Cast { destination: Relative(10), source: Relative(4), bit_size: Field }, Not { destination: Relative(11), source: Relative(4), bit_size: U1 }, Cast { destination: Relative(12), source: Relative(4), bit_size: Field }, Not { destination: Relative(13), source: Relative(4), bit_size: U1 }, Cast { destination: Relative(14), source: Relative(4), bit_size: Field }, JumpIf { condition: Relative(7), location: 220 }, Jump { location: 233 }, JumpIf { condition: Relative(6), location: 229 }, Jump { location: 222 }, Not { destination: Relative(25), source: Relative(4), bit_size: U1 }, Cast { destination: Relative(26), source: Relative(4), bit_size: Field }, Cast { destination: Relative(27), source: Relative(25), bit_size: Field }, BinaryFieldOp { destination: Relative(25), op: Mul, lhs: Relative(26), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(26), op: Add, lhs: Relative(25), rhs: Relative(27) }, Mov { destination: Relative(7), source: Relative(26) }, Jump { location: 231 }, Mov { destination: Relative(7), source: Relative(23) }, Jump { location: 231 }, Store { destination_pointer: Relative(1), source: Relative(7) }, Jump { location: 233 }, Load { destination: Relative(25), source_pointer: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(25), rhs: Relative(23) }, JumpIf { condition: Relative(1), location: 238 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, JumpIf { condition: Relative(4), location: 245 }, Jump { location: 240 }, Cast { destination: Relative(1), source: Relative(15), bit_size: Field }, BinaryFieldOp { destination: Relative(15), op: Mul, lhs: Relative(16), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(16), op: Add, lhs: Relative(15), rhs: Relative(1) }, Mov { destination: Relative(7), source: Relative(16) }, Jump { location: 247 }, Mov { destination: Relative(7), source: Relative(23) }, Jump { location: 247 }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(7) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(7), rhs: Relative(3) }, JumpIf { condition: Relative(15), location: 253 }, Jump { location: 264 }, JumpIf { condition: Relative(6), location: 260 }, Jump { location: 255 }, Cast { destination: Relative(15), source: Relative(2), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Mul, lhs: Relative(8), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(8), op: Add, lhs: Relative(2), rhs: Relative(15) }, Mov { destination: Relative(7), source: Relative(8) }, Jump { location: 262 }, Mov { destination: Relative(7), source: Relative(23) }, Jump { location: 262 }, Store { destination_pointer: Relative(1), source: Relative(7) }, Jump { location: 264 }, Load { destination: Relative(7), source_pointer: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(7), rhs: Relative(24) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 270 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, JumpIf { condition: Relative(6), location: 277 }, Jump { location: 272 }, Cast { destination: Relative(1), source: Relative(9), bit_size: Field }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(10), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(8), op: Add, lhs: Relative(7), rhs: Relative(1) }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 279 }, Mov { destination: Relative(2), source: Relative(23) }, Jump { location: 279 }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 285 }, Jump { location: 296 }, JumpIf { condition: Relative(4), location: 292 }, Jump { location: 287 }, Cast { destination: Relative(7), source: Relative(17), bit_size: Field }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(18), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(9), op: Add, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(9) }, Jump { location: 294 }, Mov { destination: Relative(2), source: Relative(23) }, Jump { location: 294 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 296 }, Load { destination: Relative(7), source_pointer: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(7), rhs: Relative(24) }, JumpIf { condition: Relative(1), location: 301 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, JumpIf { condition: Relative(6), location: 308 }, Jump { location: 303 }, Cast { destination: Relative(1), source: Relative(11), bit_size: Field }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(12), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(8), op: Add, lhs: Relative(7), rhs: Relative(1) }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 310 }, Mov { destination: Relative(2), source: Relative(23) }, Jump { location: 310 }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 316 }, Jump { location: 327 }, JumpIf { condition: Relative(4), location: 323 }, Jump { location: 318 }, Cast { destination: Relative(7), source: Relative(19), bit_size: Field }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(20), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(9), op: Add, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(9) }, Jump { location: 325 }, Mov { destination: Relative(2), source: Relative(23) }, Jump { location: 325 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 327 }, Load { destination: Relative(7), source_pointer: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(7), rhs: Relative(23) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 333 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, JumpIf { condition: Relative(4), location: 340 }, Jump { location: 335 }, Cast { destination: Relative(1), source: Relative(21), bit_size: Field }, BinaryFieldOp { destination: Relative(4), op: Mul, lhs: Relative(22), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(5), op: Add, lhs: Relative(4), rhs: Relative(1) }, Mov { destination: Relative(2), source: Relative(5) }, Jump { location: 342 }, Mov { destination: Relative(2), source: Relative(23) }, Jump { location: 342 }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 348 }, Jump { location: 359 }, JumpIf { condition: Relative(6), location: 355 }, Jump { location: 350 }, Cast { destination: Relative(3), source: Relative(13), bit_size: Field }, BinaryFieldOp { destination: Relative(4), op: Mul, lhs: Relative(14), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(5), op: Add, lhs: Relative(4), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(5) }, Jump { location: 357 }, Mov { destination: Relative(2), source: Relative(23) }, Jump { location: 357 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 359 }, Load { destination: Relative(2), source_pointer: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Relative(23) }, JumpIf { condition: Relative(1), location: 364 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 370 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 15 }, Call { location: 16 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 362 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 21 }, Call { location: 368 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 26 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 30 }, Call { location: 371 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 35 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 43 }, BinaryIntOp { destination: Relative(8), op: Div, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 43 }, Call { location: 374 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 48 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 54 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 62 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: And, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 68 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 74 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: Xor, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 80 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 85 }, Call { location: 377 }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 72 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 91 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 96 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 102 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(1), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(2), source: Relative(6), bit_size: Field }, Not { destination: Relative(7), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(8), source: Relative(6), bit_size: Field }, Not { destination: Relative(9), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(10), source: Relative(6), bit_size: Field }, Not { destination: Relative(11), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(12), source: Relative(6), bit_size: Field }, Not { destination: Relative(13), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(14), source: Relative(6), bit_size: Field }, Not { destination: Relative(15), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(16), source: Relative(6), bit_size: Field }, Not { destination: Relative(17), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(18), source: Relative(6), bit_size: Field }, Not { destination: Relative(19), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(20), source: Relative(6), bit_size: Field }, Not { destination: Relative(21), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(22), source: Relative(6), bit_size: Field }, Const { destination: Relative(23), bit_size: Field, value: 0 }, Const { destination: Relative(24), bit_size: Field, value: 2 }, JumpIf { condition: Relative(4), location: 133 }, Jump { location: 126 }, Not { destination: Relative(25), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Cast { destination: Relative(27), source: Relative(25), bit_size: Field }, BinaryFieldOp { destination: Relative(25), op: Mul, lhs: Relative(26), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(26), op: Add, lhs: Relative(25), rhs: Relative(27) }, Mov { destination: Relative(3), source: Relative(26) }, Jump { location: 135 }, Mov { destination: Relative(3), source: Relative(23) }, Jump { location: 135 }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(3), rhs: Relative(23) }, JumpIf { condition: Relative(26), location: 139 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, JumpIf { condition: Relative(4), location: 146 }, Jump { location: 141 }, Cast { destination: Relative(3), source: Relative(1), bit_size: Field }, BinaryFieldOp { destination: Relative(1), op: Mul, lhs: Relative(2), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(2), op: Add, lhs: Relative(1), rhs: Relative(3) }, Mov { destination: Relative(25), source: Relative(2) }, Jump { location: 148 }, Mov { destination: Relative(25), source: Relative(23) }, Jump { location: 148 }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(25), rhs: Relative(24) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(3), location: 153 }, Const { destination: Relative(25), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(25) } }, JumpIf { condition: Relative(4), location: 160 }, Jump { location: 155 }, Cast { destination: Relative(2), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(8), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(7), op: Add, lhs: Relative(3), rhs: Relative(2) }, Mov { destination: Relative(1), source: Relative(7) }, Jump { location: 162 }, Mov { destination: Relative(1), source: Relative(23) }, Jump { location: 162 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(24) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 167 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, JumpIf { condition: Relative(4), location: 174 }, Jump { location: 169 }, Cast { destination: Relative(1), source: Relative(9), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(10), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(7), op: Add, lhs: Relative(3), rhs: Relative(1) }, Mov { destination: Relative(2), source: Relative(7) }, Jump { location: 176 }, Mov { destination: Relative(2), source: Relative(23) }, Jump { location: 176 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(23) }, JumpIf { condition: Relative(3), location: 180 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, JumpIf { condition: Relative(4), location: 187 }, Jump { location: 182 }, Cast { destination: Relative(2), source: Relative(11), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(12), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(7), op: Add, lhs: Relative(3), rhs: Relative(2) }, Mov { destination: Relative(1), source: Relative(7) }, Jump { location: 189 }, Mov { destination: Relative(1), source: Relative(23) }, Jump { location: 189 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(23) }, JumpIf { condition: Relative(3), location: 193 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, JumpIf { condition: Relative(4), location: 200 }, Jump { location: 195 }, Cast { destination: Relative(1), source: Relative(13), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(14), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(7), op: Add, lhs: Relative(3), rhs: Relative(1) }, Mov { destination: Relative(2), source: Relative(7) }, Jump { location: 202 }, Mov { destination: Relative(2), source: Relative(23) }, Jump { location: 202 }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, Const { destination: Relative(3), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(3) }, Not { destination: Relative(2), source: Relative(4), bit_size: U1 }, Cast { destination: Relative(8), source: Relative(4), bit_size: Field }, Not { destination: Relative(9), source: Relative(4), bit_size: U1 }, Cast { destination: Relative(10), source: Relative(4), bit_size: Field }, Not { destination: Relative(11), source: Relative(4), bit_size: U1 }, Cast { destination: Relative(12), source: Relative(4), bit_size: Field }, Not { destination: Relative(13), source: Relative(4), bit_size: U1 }, Cast { destination: Relative(14), source: Relative(4), bit_size: Field }, JumpIf { condition: Relative(7), location: 217 }, Jump { location: 230 }, JumpIf { condition: Relative(6), location: 226 }, Jump { location: 219 }, Not { destination: Relative(25), source: Relative(4), bit_size: U1 }, Cast { destination: Relative(26), source: Relative(4), bit_size: Field }, Cast { destination: Relative(27), source: Relative(25), bit_size: Field }, BinaryFieldOp { destination: Relative(25), op: Mul, lhs: Relative(26), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(26), op: Add, lhs: Relative(25), rhs: Relative(27) }, Mov { destination: Relative(7), source: Relative(26) }, Jump { location: 228 }, Mov { destination: Relative(7), source: Relative(23) }, Jump { location: 228 }, Store { destination_pointer: Relative(1), source: Relative(7) }, Jump { location: 230 }, Load { destination: Relative(25), source_pointer: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(25), rhs: Relative(23) }, JumpIf { condition: Relative(1), location: 235 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, JumpIf { condition: Relative(4), location: 242 }, Jump { location: 237 }, Cast { destination: Relative(1), source: Relative(15), bit_size: Field }, BinaryFieldOp { destination: Relative(15), op: Mul, lhs: Relative(16), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(16), op: Add, lhs: Relative(15), rhs: Relative(1) }, Mov { destination: Relative(7), source: Relative(16) }, Jump { location: 244 }, Mov { destination: Relative(7), source: Relative(23) }, Jump { location: 244 }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(7) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(7), rhs: Relative(3) }, JumpIf { condition: Relative(15), location: 250 }, Jump { location: 261 }, JumpIf { condition: Relative(6), location: 257 }, Jump { location: 252 }, Cast { destination: Relative(15), source: Relative(2), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Mul, lhs: Relative(8), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(8), op: Add, lhs: Relative(2), rhs: Relative(15) }, Mov { destination: Relative(7), source: Relative(8) }, Jump { location: 259 }, Mov { destination: Relative(7), source: Relative(23) }, Jump { location: 259 }, Store { destination_pointer: Relative(1), source: Relative(7) }, Jump { location: 261 }, Load { destination: Relative(7), source_pointer: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(7), rhs: Relative(24) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 267 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, JumpIf { condition: Relative(6), location: 274 }, Jump { location: 269 }, Cast { destination: Relative(1), source: Relative(9), bit_size: Field }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(10), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(8), op: Add, lhs: Relative(7), rhs: Relative(1) }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 276 }, Mov { destination: Relative(2), source: Relative(23) }, Jump { location: 276 }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 282 }, Jump { location: 293 }, JumpIf { condition: Relative(4), location: 289 }, Jump { location: 284 }, Cast { destination: Relative(7), source: Relative(17), bit_size: Field }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(18), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(9), op: Add, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(9) }, Jump { location: 291 }, Mov { destination: Relative(2), source: Relative(23) }, Jump { location: 291 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 293 }, Load { destination: Relative(7), source_pointer: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(7), rhs: Relative(24) }, JumpIf { condition: Relative(1), location: 298 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, JumpIf { condition: Relative(6), location: 305 }, Jump { location: 300 }, Cast { destination: Relative(1), source: Relative(11), bit_size: Field }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(12), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(8), op: Add, lhs: Relative(7), rhs: Relative(1) }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 307 }, Mov { destination: Relative(2), source: Relative(23) }, Jump { location: 307 }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 313 }, Jump { location: 324 }, JumpIf { condition: Relative(4), location: 320 }, Jump { location: 315 }, Cast { destination: Relative(7), source: Relative(19), bit_size: Field }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(20), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(9), op: Add, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(9) }, Jump { location: 322 }, Mov { destination: Relative(2), source: Relative(23) }, Jump { location: 322 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 324 }, Load { destination: Relative(7), source_pointer: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(7), rhs: Relative(23) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 330 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, JumpIf { condition: Relative(4), location: 337 }, Jump { location: 332 }, Cast { destination: Relative(1), source: Relative(21), bit_size: Field }, BinaryFieldOp { destination: Relative(4), op: Mul, lhs: Relative(22), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(5), op: Add, lhs: Relative(4), rhs: Relative(1) }, Mov { destination: Relative(2), source: Relative(5) }, Jump { location: 339 }, Mov { destination: Relative(2), source: Relative(23) }, Jump { location: 339 }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 345 }, Jump { location: 356 }, JumpIf { condition: Relative(6), location: 352 }, Jump { location: 347 }, Cast { destination: Relative(3), source: Relative(13), bit_size: Field }, BinaryFieldOp { destination: Relative(4), op: Mul, lhs: Relative(14), rhs: Relative(24) }, BinaryFieldOp { destination: Relative(5), op: Add, lhs: Relative(4), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(5) }, Jump { location: 354 }, Mov { destination: Relative(2), source: Relative(23) }, Jump { location: 354 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 356 }, Load { destination: Relative(2), source_pointer: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Relative(23) }, JumpIf { condition: Relative(1), location: 361 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 367 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "tVnLbiM5DPwXn3MQ9SCl/MpgMPBkPAMDhhN4kgUWQf59WRbZSQ7qDdTwJVVOt9gsukRJ7tfdr8PPlz8/juffj393999edz8vx9Pp+OfH6fFh/3x8POt/X3cBf0h29/FuR7VDu0IMHWh3nxRih9QhdygdeHdfFKRD7dCukDQKK1CH2CF1yB00SlXgDtKhdmhXyKEDdYgdNEpTyB1KB+4gHTQKkaKGIRVTgiEZRsNkqLEoKxZDNtRwpGpKNWwdORiSIeKJIuJpipwNiyEbiiEqHhRRcs1TgiEZRsNkqPGiVlw0XtS8hA3FsBq2jhXxNK9KhtEQ8TTPmg2LIRuKYTVEPM23BUMyjIbJEL5QPQ3G0HwbG4phNdR4SXVQ0IApg5CT6CQ5yU4QVUA0bA4g4kQDZgQkjZMZRIfnBqKjyvUS/InhMDhrFgRvcwGBIXEzXCsICP8J7oEDrwQe7ISMwEWpgmjOgpkDH3WSnRQjsEDGKHhAkA9M0El10ozg+xNIxhfYCTmJRlB7QfIofifZSekkomKFQNiJOMFDBaQZodDLGyk6yU7YSPRLmNBSQZITvbkEkOKEnYgRTMuCxDAxO2lGMDUr7sEcqsgQk6cTBMwg7EScVCfNCEpX0bdQuk7ICSLjHhSqNBB2goBQAYd20jpJsOiVoD4VLQ0e6yQ60SJUQX/TVDmBiBMNyBGkGbm2xCshJ9EIOhsjDnpbJ9kJumRDt0RrCyDNCLpQIxByEp2gR9Lb293Ou/6P58vhgKb/YRnQxeFpfzmcn3f355fT6W73z/70cr3p79P+fMXn/UWv6tMO51+KGvD38XQAe7t7Hx3GQ7XENjiFvAwvn8fTeDwxGsw1gM6lOIqwmgF7BnFmfEqLgjxUkFcUSPYAJEJTGSwKeEqBLArqUIGsKKjsCVBtYSoDD5DDjIJMriDHsYtWAlDDhL1GiCG0qRQWCXlKQlkk8FhCWvGxrogugWKdSmGRUKckNJ+KJZShBF6REGNzCbGkqRS8iiWWifEley8rWYYS2oqEVKJLUFfPpJC8BoVlZnz1BEodGjnGFQl56Qe6/NJUCmQBeGoucVrGpxkjcyz/Pz6uGbG0ZS4xpakUPADzjBG5uhG5DZ8f14wowWdzlKm5wOJGlDjT1GVZlmS8MKY1I9awNOWa5lLwAFJmjCji36LU4UTAM8abC1oktDhMIa14sZS49KSSPvTlr4qo5OMrDWcDDixbRbQ1Ee9dSefWhIjsa0stQzNn2iwix1uKqG6n2oYLbM7bRZQbimjRm3OLw/Upy3YR9YYi9NS/bLrjeI0qa3tWarQcHMbLZNnuyXJLT1LEL0dWiTLcsJS8vRLb+2Thm1ZCvFFSGh9Dyoov9Xz/XonxilHa5kpwuGUl0nKYoZTHOcTNleC0vRL5ppXgvFRifChi3jw7eHvH5M0dM91yfol4o5E2sx+twfejNc1syevyO0vlmc1grZ5/CzMHsw8LZy5TK05cdoIpjo+nsmbG99NlKsyDL3E9ia+1uLxdR9usI2/XUbeve3VzKWraWorVXv3FDhW369hszdVO+8Uk6m2T+JKvvrjmZPrcqb7rp/3D8fLpbe0bYl2O+5+ng338/XJ++HD1+d8nv+Jve58ujw+HXy+XAyJ9eOWrf78lffmVJHzHOzF81EOw/pT1/Q2P/w8=", + "debug_symbols": "tVndTiM9DH2XXnMR58d2eJUVQgXKqlJVUBc+6RPi3ddu7AEuEnUz6g3nlJmc+jiOk+l8bJ52D++/7/fH55c/m9tfH5uH0/5w2P++P7w8bt/2L0f578cm6B+gzW282QA3qGeIoQFsbpNAbJAa5AalAW5uiwA14Ab1DElUUAAaxAapQW4gKiyADagBN6hnyKEBNIgNRKUK5AalATagBqICICgyIGZKMATDaJgMRQuyYDFEQ5EDcVPYsDbEYAiGqkeCqichYjYshmhIhprxIKgplzgpGIJhNEyGohcl4yR6UeIiNCRDNqwNWfUkxQyG0TAZZsNiqHoSP5MhG9aGNRiqnuS3alVI/DUZZsNiKHpJ8lpFL0nclQ1rQwjBCThRSVSimlVJdiJqWQs0iEyWdAPI8MxKZFTRSyA3Fx0OcjMGJXIzSi5ACxr1Zq1XVEGtPNJ7tPYaISdsREsokRKJmWQOQIuoEXASjej8Zx2lBUAaj1ZAI8UJGtHJI7Wss9cIO6lGNPGkwWvmGwEnsZGoGStBSXKSneiXohJ0Qi29MVQjAE6SE7+kS5lIV31wIjfnqiQ6SU6yEV2QRQPTJdkIOlGneo8uINYIdeU0oi7OzSQ5yU6KEzSiqWNQQk7YiSrrPZqowkqSExVUF1qejaATaiRpfjgrYSfViBYbn5uYdrGoJDsRQQQl6IScsJNqRHsanttfcAJOtLNp29NGxFUJOtGOFpSwk2pEu1ANn583G2/t92+n3U47+7deLzvA6/a0O75tbo/vh8PN5r/t4f1805/X7fGMb9uTXBXJ3fFJUASf94edss+br9GhP1TyaINTyMvw8nM89McDBjQBWUKhpzCMwAVkmibGp7Q4yF0HeeCAYnEHlOtUBIsDnHJAiwPuOqCBA87ZHTDyVATuIIcZBxncQY79KhoIQMXkFirTVAiLhTxloSwWsG8hDeo4cDSFKBvfVAiLBZ6yUNnGl1C6FnBgQTYbtyAbx1QILlBimRhfsveykrtVAHVgISVXiNKTZ0LQk0sLAWcKsSxlULjbTWIcWMjFG5Jsv3UqBDABDDPjcemImFLXQhlYKOQdSQ4OcyG4AE7NIqLPIlJ3FiMPLGBdLBBMWUBfjlhnmjKBB0D9jTEN9mY5WXkSIsc8FYJ3ZUoza4GKrwUq3RSmPDochMVCjd1aTINaLCUuPaWkb4m82AT7PFLttvVE603wyMRXVyk1/7sJjr63cH9J57DaRIZrmkAfz9Q9aua03kS+pollUdb+Lp1xvQm6ogmAZY+Sx/Vua8iDnToBu0SC2s1EWV+T5Zo1KT9S+GYL8kTdjSGtz8T6PlnKVTOReckEd9dnGdSlPI0vmYjUzwSvz0S9aiaWswOIj14MCKszgXF1JjBdMxMpxyUT2K0JLKtXB67vmLi6Y6Zrri8q3miI0sxhjP3ZjGHm2Y6XpwLOM4dBRo+feebZ8NvGOdj1RjtOXE7U8kNgNwU0Ksavp0P5oQ87kzgO4rIWl9b74LU+xkFc5oPW73u0OhUc16Zi2Ksv7FCw3sfq0hx22guDoOsGcVFdXbrn1J+d6k4+bR/3px+vVD9V67TfPhx29vH5/fj47erb/69+xV/Jvp5eHndP76edKn17Lyt/f8mvwDcJ6U5fZelHedGUKN196tf/BQ==", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n if result {\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use super::{Eq, max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0_u64, 1), 0);\n assert_eq(min(0_u64, 0), 0);\n assert_eq(min(1_u64, 1), 1);\n assert_eq(min(255_u8, 0), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0_u64, 1), 1);\n assert_eq(max(0_u64, 0), 0);\n assert_eq(max(1_u64, 1), 1);\n assert_eq(max(255_u8, 0), 255);\n }\n\n #[test]\n fn correctly_handles_unequal_length_slices() {\n let slice_1 = &[0, 1, 2, 3];\n let slice_2 = &[0, 1, 2];\n assert(!slice_1.eq(slice_2));\n }\n}\n", "path": "std/cmp.nr" }, "50": { - "source": "use std::cmp::Ordering;\nuse std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Rem, Shl, Shr, Sub};\n\n// x = 3, y = 9\nfn main(x: u32, y: u32) {\n let wx = Wrapper::new(x);\n let wy = Wrapper::new(y);\n\n // expected x and expected y values\n let ex: u32 = 3;\n let ey: u32 = 9;\n\n assert((wx + wy).inner == ex + ey);\n assert((wy - wx).inner == ey - ex);\n assert((wx * wy).inner == ex * ey);\n assert((wx / wy).inner == ex / ey);\n assert((wx % wy).inner == ex % ey);\n\n assert((wx & wy).inner == (ex & ey));\n assert((wx | wy).inner == (ex | ey));\n assert((wx ^ wy).inner == (ex ^ ey));\n\n assert((wy << x as u8).inner == (ey << ex as u8));\n assert((wy >> x as u8).inner == (ey >> ex as u8));\n\n assert((wx == wy) == (ex == ey));\n assert((wx < wy) == (ex < ey));\n assert((wx <= wy) == (ex <= ey));\n assert((wx > wy) == (ex > ey));\n assert((wx >= wy) == (ex >= ey));\n assert(wx.cmp(wy) == ex.cmp(ey));\n\n // Ensure operator overloading still works with more complex types\n let pair_ascending = Pair { x: wx, y: wy };\n let pair_descending = Pair { x: wy, y: wx };\n\n assert(pair_ascending != pair_descending);\n\n assert(pair_ascending < pair_descending);\n assert(pair_ascending <= pair_descending);\n assert(pair_descending > pair_ascending);\n assert(pair_descending >= pair_ascending);\n\n assert(pair_ascending.cmp(pair_descending) == Ordering::less());\n}\n\nstruct Wrapper {\n inner: u32,\n}\n\nimpl Wrapper {\n fn new(inner: u32) -> Self {\n Wrapper { inner }\n }\n}\n\nimpl Add for Wrapper {\n fn add(self, other: Self) -> Self {\n Wrapper::new(self.inner + other.inner)\n }\n}\n\nimpl Sub for Wrapper {\n fn sub(self, other: Self) -> Self {\n Wrapper::new(self.inner - other.inner)\n }\n}\n\nimpl Mul for Wrapper {\n fn mul(self, other: Self) -> Self {\n Wrapper::new(self.inner * other.inner)\n }\n}\n\nimpl Div for Wrapper {\n fn div(self, other: Self) -> Self {\n Wrapper::new(self.inner / other.inner)\n }\n}\n\nimpl Rem for Wrapper {\n fn rem(self, other: Self) -> Self {\n Wrapper::new(self.inner % other.inner)\n }\n}\n\nimpl BitAnd for Wrapper {\n fn bitand(self, other: Self) -> Self {\n Wrapper::new(self.inner & other.inner)\n }\n}\n\nimpl BitOr for Wrapper {\n fn bitor(self, other: Self) -> Self {\n Wrapper::new(self.inner | other.inner)\n }\n}\n\nimpl BitXor for Wrapper {\n fn bitxor(self, other: Self) -> Self {\n Wrapper::new(self.inner ^ other.inner)\n }\n}\n\nimpl Shl for Wrapper {\n fn shl(self, other: u8) -> Self {\n Wrapper::new(self.inner << other)\n }\n}\n\nimpl Shr for Wrapper {\n fn shr(self, other: u8) -> Self {\n Wrapper::new(self.inner >> other)\n }\n}\n\nimpl Eq for Wrapper {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nimpl Ord for Wrapper {\n fn cmp(self, other: Self) -> Ordering {\n self.inner.cmp(other.inner)\n }\n}\n\nstruct Pair {\n x: Wrapper,\n y: Wrapper,\n}\n\nimpl Eq for Pair {\n fn eq(self, o: Self) -> bool {\n (self.x == o.x) & (self.y == o.y)\n }\n}\n\nimpl Ord for Pair {\n fn cmp(self, o: Self) -> Ordering {\n let mut result = self.x.cmp(o.x);\n\n if result == Ordering::equal() {\n result = self.y.cmp(o.y);\n }\n\n result\n }\n}\n", + "source": "use std::cmp::Ordering;\nuse std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Rem, Shl, Shr, Sub};\n\n// x = 3, y = 9\nfn main(x: u32, y: u32) {\n let wx = Wrapper::new(x);\n let wy = Wrapper::new(y);\n\n // expected x and expected y values\n let ex: u32 = 3;\n let ey: u32 = 9;\n\n assert((wx + wy).inner == ex + ey);\n assert((wy - wx).inner == ey - ex);\n assert((wx * wy).inner == ex * ey);\n assert((wx / wy).inner == ex / ey);\n assert((wx % wy).inner == ex % ey);\n\n assert((wx & wy).inner == (ex & ey));\n assert((wx | wy).inner == (ex | ey));\n assert((wx ^ wy).inner == (ex ^ ey));\n\n assert((wy << wx).inner == (ey << ex));\n assert((wy >> wx).inner == (ey >> ex));\n\n assert((wx == wy) == (ex == ey));\n assert((wx < wy) == (ex < ey));\n assert((wx <= wy) == (ex <= ey));\n assert((wx > wy) == (ex > ey));\n assert((wx >= wy) == (ex >= ey));\n assert(wx.cmp(wy) == ex.cmp(ey));\n\n // Ensure operator overloading still works with more complex types\n let pair_ascending = Pair { x: wx, y: wy };\n let pair_descending = Pair { x: wy, y: wx };\n\n assert(pair_ascending != pair_descending);\n\n assert(pair_ascending < pair_descending);\n assert(pair_ascending <= pair_descending);\n assert(pair_descending > pair_ascending);\n assert(pair_descending >= pair_ascending);\n\n assert(pair_ascending.cmp(pair_descending) == Ordering::less());\n}\n\nstruct Wrapper {\n inner: u32,\n}\n\nimpl Wrapper {\n fn new(inner: u32) -> Self {\n Wrapper { inner }\n }\n}\n\nimpl Add for Wrapper {\n fn add(self, other: Self) -> Self {\n Wrapper::new(self.inner + other.inner)\n }\n}\n\nimpl Sub for Wrapper {\n fn sub(self, other: Self) -> Self {\n Wrapper::new(self.inner - other.inner)\n }\n}\n\nimpl Mul for Wrapper {\n fn mul(self, other: Self) -> Self {\n Wrapper::new(self.inner * other.inner)\n }\n}\n\nimpl Div for Wrapper {\n fn div(self, other: Self) -> Self {\n Wrapper::new(self.inner / other.inner)\n }\n}\n\nimpl Rem for Wrapper {\n fn rem(self, other: Self) -> Self {\n Wrapper::new(self.inner % other.inner)\n }\n}\n\nimpl BitAnd for Wrapper {\n fn bitand(self, other: Self) -> Self {\n Wrapper::new(self.inner & other.inner)\n }\n}\n\nimpl BitOr for Wrapper {\n fn bitor(self, other: Self) -> Self {\n Wrapper::new(self.inner | other.inner)\n }\n}\n\nimpl BitXor for Wrapper {\n fn bitxor(self, other: Self) -> Self {\n Wrapper::new(self.inner ^ other.inner)\n }\n}\n\nimpl Shl for Wrapper {\n fn shl(self, other: Self) -> Self {\n Wrapper::new(self.inner << other.inner)\n }\n}\n\nimpl Shr for Wrapper {\n fn shr(self, other: Self) -> Self {\n Wrapper::new(self.inner >> other.inner)\n }\n}\n\nimpl Eq for Wrapper {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nimpl Ord for Wrapper {\n fn cmp(self, other: Self) -> Ordering {\n self.inner.cmp(other.inner)\n }\n}\n\nstruct Pair {\n x: Wrapper,\n y: Wrapper,\n}\n\nimpl Eq for Pair {\n fn eq(self, o: Self) -> bool {\n (self.x == o.x) & (self.y == o.y)\n }\n}\n\nimpl Ord for Pair {\n fn cmp(self, o: Self) -> Ordering {\n let mut result = self.x.cmp(o.x);\n\n if result == Ordering::equal() {\n result = self.y.cmp(o.y);\n }\n\n result\n }\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__expanded.snap index 4608d115a1e..2ed86f9d457 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__expanded.snap @@ -5,30 +5,28 @@ expression: expanded_code fn main(x: u64) { let two: u64 = 2_u64; let three: u64 = 3_u64; - assert((two << 2_u8) == 8_u64); - assert(((two << 3_u8) / 8_u64) == two); - assert((three >> 1_u8) == 1_u64); - assert((x << 1_u8) == 128_u64); - assert((x >> 2_u8) == 16_u64); + assert((two << 2_u64) == 8_u64); + assert(((two << 3_u64) / 8_u64) == two); + assert((three >> 1_u64) == 1_u64); + assert((x << 1_u64) == 128_u64); + assert((x >> 2_u64) == 16_u64); regression_2250(); - assert((x << 63_u8) == 0_u64); - assert((1_u64 << 32_u8) == 4294967296_u64); + assert((x << 63_u64) == 0_u64); + assert((1_u64 << 32_u64) == 4294967296_u64); let a: i16 = -769_i16; - assert((a >> 3_u8) == -97_i16); + assert((a >> 3_i16) == -97_i16); regression_8310(); - assert((-(x as i64) >> 63_u8) == -1_i64); - assert((a >> 27_u8) == -1_i16); + assert((-(x as i64) >> 62_i64) == -1_i64); + assert((a >> 14_i16) == -1_i16); } fn regression_2250() { - let a: u1 = 1_u1 >> 1_u8; - assert(a == 0_u1); - let b: u32 = 1_u32 >> 32_u8; + let b: u32 = 1_u32 >> 31_u32; assert(b == 0_u32); } fn regression_8310() { let x: i64 = -356710612598522715_i64; - let b: i64 = x >> 64_u8; + let b: i64 = x >> 62_i64; assert(b == -1_i64); } diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 313355ce16d..a2c098c18a0 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -73,14 +73,14 @@ expression: artifact "BLACKBOX::RANGE [(_19, 1)] []", "BLACKBOX::RANGE [(_20, 63)] []", "EXPR [ (1, _18) (-9223372036854775808, _19) (-1, _20) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _18, _19) (1, _18) (18446744073709551616, _19) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_21, _22]", - "BLACKBOX::RANGE [(_21, 1)] []", - "BLACKBOX::RANGE [(_22, 63)] []", - "EXPR [ (-2, _18, _19) (1, _18) (18446744073709551616, _19) (-9223372036854775808, _21) (-1, _22) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _18, _19) (1, _18) (18446744073709551616, _19) 0 ], EXPR [ 4611686018427387904 ]], outputs: [_21, _22]", + "BLACKBOX::RANGE [(_21, 2)] []", + "BLACKBOX::RANGE [(_22, 62)] []", + "EXPR [ (-2, _18, _19) (1, _18) (18446744073709551616, _19) (-4611686018427387904, _21) (-1, _22) 0 ]", "BRILLIG CALL func 1: inputs: [EXPR [ (1, _21) 0 ]], outputs: [_23]", "EXPR [ (1, _21, _23) (1, _24) -1 ]", "EXPR [ (1, _21, _24) 0 ]", - "EXPR [ (2, _19, _21) (-18446744073709551616, _19) (-1, _21) (-1, _25) 18446744073709551616 ]", + "EXPR [ (-2, _19, _21) (18446744073709551616, _19) (1, _21) (-1, _25) 0 ]", "EXPR [ (-1, _24) (-1, _26) 1 ]", "BRILLIG CALL func 1: inputs: [EXPR [ (1, _22) 0 ]], outputs: [_27]", "EXPR [ (1, _22, _27) (1, _28) -1 ]", @@ -99,7 +99,7 @@ expression: artifact "debug_symbols": "pZTNjoIwFEbfpesuaHsvP77KZGIqVkPSAKlgMjG++1z7iaOL2cCmByjnhLSkN3UMh/m87/rTcFG7r5s6pC7G7ryPQ+unbujl6e2u1XK7n1II8ki9zYs1+hT6Se36OUatrj7O+aXL6PvMySeZLbQK/VEowVMXw+Pqrv/s4n/VOveUrWteOq/xqVzjl8vH23KjX9kVvnPV03dEG/0168ev9WMyq3zz8u1Gv97m8+f6fcudb7v08ccro3Yi2Dy6PJJsnVYsC6hVmccqj7XakVaNxLQyBWAA0UuB+LWAAAZKoAJqoMmwBWAAC6BiUbGoWKk0ggqogSbDFYABLOAAAhhAxaHiUHGoECqECqFCqBAqhAqhQqgQKoQKo8KoMCqMCqPCqDAqjAqjwlIxj0Pj6lPnDzE8D6XT3LdvZ9T0My4zyyk2pqENxzmFx+7mOdnvXw==", "file_map": { "50": { - "source": "fn main(x: u64) {\n let two: u64 = 2;\n let three: u64 = 3;\n // shifts on constant values\n assert(two << 2 == 8);\n assert((two << 3) / 8 == two);\n assert((three >> 1) == 1);\n // shifts on runtime values\n assert(x << 1 == 128);\n assert(x >> 2 == 16);\n\n regression_2250();\n\n //regression for 3481\n assert(x << 63 == 0);\n\n assert_eq(1_u64 << 32, 0x0100000000);\n\n //regression for 6201\n let a: i16 = -769;\n assert_eq(a >> 3, -97);\n\n regression_8310();\n\n //regression 8791\n assert(-(x as i64) >> 63 == -1);\n assert(a >> 27 == -1);\n}\n\nfn regression_2250() {\n let a: u1 = 1 >> 1;\n assert(a == 0);\n\n let b: u32 = 1 >> 32;\n assert(b == 0);\n}\n\nfn regression_8310() {\n let x: i64 = -356710612598522715;\n let b = x >> 64;\n assert(b == -1);\n}\n", + "source": "fn main(x: u64) {\n let two: u64 = 2;\n let three: u64 = 3;\n // shifts on constant values\n assert(two << 2 == 8);\n assert((two << 3) / 8 == two);\n assert((three >> 1) == 1);\n // shifts on runtime values\n assert(x << 1 == 128);\n assert(x >> 2 == 16);\n\n regression_2250();\n\n //regression for 3481\n assert(x << 63 == 0);\n\n assert_eq(1_u64 << 32, 0x0100000000);\n\n //regression for 6201\n let a: i16 = -769;\n assert_eq(a >> 3, -97);\n\n regression_8310();\n\n //regression 8791\n assert(-(x as i64) >> 62 == -1);\n assert(a >> 14 == -1);\n}\n\nfn regression_2250() {\n let b: u32 = 1 >> 31;\n assert(b == 0);\n}\n\nfn regression_8310() {\n let x: i64 = -356710612598522715;\n let b = x >> 62;\n assert(b == -1);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_false_inliner_0.snap index 313355ce16d..a2c098c18a0 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_false_inliner_0.snap @@ -73,14 +73,14 @@ expression: artifact "BLACKBOX::RANGE [(_19, 1)] []", "BLACKBOX::RANGE [(_20, 63)] []", "EXPR [ (1, _18) (-9223372036854775808, _19) (-1, _20) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _18, _19) (1, _18) (18446744073709551616, _19) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_21, _22]", - "BLACKBOX::RANGE [(_21, 1)] []", - "BLACKBOX::RANGE [(_22, 63)] []", - "EXPR [ (-2, _18, _19) (1, _18) (18446744073709551616, _19) (-9223372036854775808, _21) (-1, _22) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _18, _19) (1, _18) (18446744073709551616, _19) 0 ], EXPR [ 4611686018427387904 ]], outputs: [_21, _22]", + "BLACKBOX::RANGE [(_21, 2)] []", + "BLACKBOX::RANGE [(_22, 62)] []", + "EXPR [ (-2, _18, _19) (1, _18) (18446744073709551616, _19) (-4611686018427387904, _21) (-1, _22) 0 ]", "BRILLIG CALL func 1: inputs: [EXPR [ (1, _21) 0 ]], outputs: [_23]", "EXPR [ (1, _21, _23) (1, _24) -1 ]", "EXPR [ (1, _21, _24) 0 ]", - "EXPR [ (2, _19, _21) (-18446744073709551616, _19) (-1, _21) (-1, _25) 18446744073709551616 ]", + "EXPR [ (-2, _19, _21) (18446744073709551616, _19) (1, _21) (-1, _25) 0 ]", "EXPR [ (-1, _24) (-1, _26) 1 ]", "BRILLIG CALL func 1: inputs: [EXPR [ (1, _22) 0 ]], outputs: [_27]", "EXPR [ (1, _22, _27) (1, _28) -1 ]", @@ -99,7 +99,7 @@ expression: artifact "debug_symbols": "pZTNjoIwFEbfpesuaHsvP77KZGIqVkPSAKlgMjG++1z7iaOL2cCmByjnhLSkN3UMh/m87/rTcFG7r5s6pC7G7ryPQ+unbujl6e2u1XK7n1II8ki9zYs1+hT6Se36OUatrj7O+aXL6PvMySeZLbQK/VEowVMXw+Pqrv/s4n/VOveUrWteOq/xqVzjl8vH23KjX9kVvnPV03dEG/0168ev9WMyq3zz8u1Gv97m8+f6fcudb7v08ccro3Yi2Dy6PJJsnVYsC6hVmccqj7XakVaNxLQyBWAA0UuB+LWAAAZKoAJqoMmwBWAAC6BiUbGoWKk0ggqogSbDFYABLOAAAhhAxaHiUHGoECqECqFCqBAqhAqhQqgQKoQKo8KoMCqMCqPCqDAqjAqjwlIxj0Pj6lPnDzE8D6XT3LdvZ9T0My4zyyk2pqENxzmFx+7mOdnvXw==", "file_map": { "50": { - "source": "fn main(x: u64) {\n let two: u64 = 2;\n let three: u64 = 3;\n // shifts on constant values\n assert(two << 2 == 8);\n assert((two << 3) / 8 == two);\n assert((three >> 1) == 1);\n // shifts on runtime values\n assert(x << 1 == 128);\n assert(x >> 2 == 16);\n\n regression_2250();\n\n //regression for 3481\n assert(x << 63 == 0);\n\n assert_eq(1_u64 << 32, 0x0100000000);\n\n //regression for 6201\n let a: i16 = -769;\n assert_eq(a >> 3, -97);\n\n regression_8310();\n\n //regression 8791\n assert(-(x as i64) >> 63 == -1);\n assert(a >> 27 == -1);\n}\n\nfn regression_2250() {\n let a: u1 = 1 >> 1;\n assert(a == 0);\n\n let b: u32 = 1 >> 32;\n assert(b == 0);\n}\n\nfn regression_8310() {\n let x: i64 = -356710612598522715;\n let b = x >> 64;\n assert(b == -1);\n}\n", + "source": "fn main(x: u64) {\n let two: u64 = 2;\n let three: u64 = 3;\n // shifts on constant values\n assert(two << 2 == 8);\n assert((two << 3) / 8 == two);\n assert((three >> 1) == 1);\n // shifts on runtime values\n assert(x << 1 == 128);\n assert(x >> 2 == 16);\n\n regression_2250();\n\n //regression for 3481\n assert(x << 63 == 0);\n\n assert_eq(1_u64 << 32, 0x0100000000);\n\n //regression for 6201\n let a: i16 = -769;\n assert_eq(a >> 3, -97);\n\n regression_8310();\n\n //regression 8791\n assert(-(x as i64) >> 62 == -1);\n assert(a >> 14 == -1);\n}\n\nfn regression_2250() {\n let b: u32 = 1 >> 31;\n assert(b == 0);\n}\n\nfn regression_8310() {\n let x: i64 = -356710612598522715;\n let b = x >> 62;\n assert(b == -1);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 313355ce16d..a2c098c18a0 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -73,14 +73,14 @@ expression: artifact "BLACKBOX::RANGE [(_19, 1)] []", "BLACKBOX::RANGE [(_20, 63)] []", "EXPR [ (1, _18) (-9223372036854775808, _19) (-1, _20) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _18, _19) (1, _18) (18446744073709551616, _19) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_21, _22]", - "BLACKBOX::RANGE [(_21, 1)] []", - "BLACKBOX::RANGE [(_22, 63)] []", - "EXPR [ (-2, _18, _19) (1, _18) (18446744073709551616, _19) (-9223372036854775808, _21) (-1, _22) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _18, _19) (1, _18) (18446744073709551616, _19) 0 ], EXPR [ 4611686018427387904 ]], outputs: [_21, _22]", + "BLACKBOX::RANGE [(_21, 2)] []", + "BLACKBOX::RANGE [(_22, 62)] []", + "EXPR [ (-2, _18, _19) (1, _18) (18446744073709551616, _19) (-4611686018427387904, _21) (-1, _22) 0 ]", "BRILLIG CALL func 1: inputs: [EXPR [ (1, _21) 0 ]], outputs: [_23]", "EXPR [ (1, _21, _23) (1, _24) -1 ]", "EXPR [ (1, _21, _24) 0 ]", - "EXPR [ (2, _19, _21) (-18446744073709551616, _19) (-1, _21) (-1, _25) 18446744073709551616 ]", + "EXPR [ (-2, _19, _21) (18446744073709551616, _19) (1, _21) (-1, _25) 0 ]", "EXPR [ (-1, _24) (-1, _26) 1 ]", "BRILLIG CALL func 1: inputs: [EXPR [ (1, _22) 0 ]], outputs: [_27]", "EXPR [ (1, _22, _27) (1, _28) -1 ]", @@ -99,7 +99,7 @@ expression: artifact "debug_symbols": "pZTNjoIwFEbfpesuaHsvP77KZGIqVkPSAKlgMjG++1z7iaOL2cCmByjnhLSkN3UMh/m87/rTcFG7r5s6pC7G7ryPQ+unbujl6e2u1XK7n1II8ki9zYs1+hT6Se36OUatrj7O+aXL6PvMySeZLbQK/VEowVMXw+Pqrv/s4n/VOveUrWteOq/xqVzjl8vH23KjX9kVvnPV03dEG/0168ev9WMyq3zz8u1Gv97m8+f6fcudb7v08ccro3Yi2Dy6PJJsnVYsC6hVmccqj7XakVaNxLQyBWAA0UuB+LWAAAZKoAJqoMmwBWAAC6BiUbGoWKk0ggqogSbDFYABLOAAAhhAxaHiUHGoECqECqFCqBAqhAqhQqgQKoQKo8KoMCqMCqPCqDAqjAqjwlIxj0Pj6lPnDzE8D6XT3LdvZ9T0My4zyyk2pqENxzmFx+7mOdnvXw==", "file_map": { "50": { - "source": "fn main(x: u64) {\n let two: u64 = 2;\n let three: u64 = 3;\n // shifts on constant values\n assert(two << 2 == 8);\n assert((two << 3) / 8 == two);\n assert((three >> 1) == 1);\n // shifts on runtime values\n assert(x << 1 == 128);\n assert(x >> 2 == 16);\n\n regression_2250();\n\n //regression for 3481\n assert(x << 63 == 0);\n\n assert_eq(1_u64 << 32, 0x0100000000);\n\n //regression for 6201\n let a: i16 = -769;\n assert_eq(a >> 3, -97);\n\n regression_8310();\n\n //regression 8791\n assert(-(x as i64) >> 63 == -1);\n assert(a >> 27 == -1);\n}\n\nfn regression_2250() {\n let a: u1 = 1 >> 1;\n assert(a == 0);\n\n let b: u32 = 1 >> 32;\n assert(b == 0);\n}\n\nfn regression_8310() {\n let x: i64 = -356710612598522715;\n let b = x >> 64;\n assert(b == -1);\n}\n", + "source": "fn main(x: u64) {\n let two: u64 = 2;\n let three: u64 = 3;\n // shifts on constant values\n assert(two << 2 == 8);\n assert((two << 3) / 8 == two);\n assert((three >> 1) == 1);\n // shifts on runtime values\n assert(x << 1 == 128);\n assert(x >> 2 == 16);\n\n regression_2250();\n\n //regression for 3481\n assert(x << 63 == 0);\n\n assert_eq(1_u64 << 32, 0x0100000000);\n\n //regression for 6201\n let a: i16 = -769;\n assert_eq(a >> 3, -97);\n\n regression_8310();\n\n //regression 8791\n assert(-(x as i64) >> 62 == -1);\n assert(a >> 14 == -1);\n}\n\nfn regression_2250() {\n let b: u32 = 1 >> 31;\n assert(b == 0);\n}\n\nfn regression_8310() {\n let x: i64 = -356710612598522715;\n let b = x >> 62;\n assert(b == -1);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 1fcb4d74447..a337590c379 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -37,12 +37,12 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U64) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 108 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 128 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 22 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(2), bit_size: Integer(U8), value: 2 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 16 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 29 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(2), bit_size: Integer(U8), value: 63 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 36 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Cast { destination: Relative(3), source: Relative(1), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U64, lhs: Relative(4), rhs: Relative(3) }, Mov { destination: Relative(3), source: Relative(5) }, Cast { destination: Relative(4), source: Relative(3), bit_size: Integer(U64) }, Const { destination: Relative(5), bit_size: Integer(U64), value: 9223372036854775808 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U64, lhs: Relative(1), rhs: Relative(5) }, Not { destination: Relative(1), source: Relative(6), bit_size: U1 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Mul, bit_size: U1, lhs: Relative(6), rhs: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 49 }, Call { location: 114 }, Const { destination: Relative(5), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U64, lhs: Relative(5), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 53 }, Jump { location: 100 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 64 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 57 }, Jump { location: 97 }, Const { destination: Relative(8), bit_size: Integer(U64), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U64), value: 2 }, Const { destination: Relative(10), bit_size: Integer(U64), value: 1 }, Cast { destination: Relative(11), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 68 }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U64, lhs: Relative(10), rhs: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Jump { location: 62 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U64, lhs: Relative(3), rhs: Relative(8) }, Const { destination: Relative(17), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U64, lhs: Relative(17), rhs: Relative(1) }, Const { destination: Relative(18), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U64, lhs: Relative(18), rhs: Relative(1) }, JumpIf { condition: Relative(12), location: 75 }, Jump { location: 77 }, Mov { destination: Relative(13), source: Relative(19) }, Jump { location: 79 }, Mov { destination: Relative(13), source: Relative(1) }, Jump { location: 79 }, Const { destination: Relative(17), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U64, lhs: Relative(17), rhs: Relative(10) }, Const { destination: Relative(18), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U64, lhs: Relative(18), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 85 }, Jump { location: 87 }, Mov { destination: Relative(15), source: Relative(19) }, Jump { location: 89 }, Mov { destination: Relative(15), source: Relative(10) }, Jump { location: 89 }, BinaryIntOp { destination: Relative(1), op: Div, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: Xor, bit_size: U1, lhs: Relative(12), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 93 }, Jump { location: 95 }, Const { destination: Relative(17), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U64, lhs: Relative(17), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U64, lhs: Relative(1), rhs: Relative(8) }, Jump { location: 99 }, Const { destination: Relative(1), bit_size: Integer(U64), value: 18446744073709551615 }, Jump { location: 99 }, Jump { location: 102 }, BinaryIntOp { destination: Relative(1), op: Shr, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, Jump { location: 102 }, Const { destination: Relative(2), bit_size: Integer(U64), value: 18446744073709551615 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 107 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 113 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U64) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 110 }, Const { destination: Relative(2), bit_size: Integer(U64), value: 1 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 128 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 22 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(2), bit_size: Integer(U64), value: 2 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 16 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 29 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(2), bit_size: Integer(U64), value: 63 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 36 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Cast { destination: Relative(2), source: Relative(1), bit_size: Integer(U64) }, Const { destination: Relative(3), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, Mov { destination: Relative(2), source: Relative(4) }, Cast { destination: Relative(3), source: Relative(2), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 9223372036854775808 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U64, lhs: Relative(1), rhs: Relative(4) }, Not { destination: Relative(1), source: Relative(5), bit_size: U1 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 49 }, Call { location: 116 }, Const { destination: Relative(1), bit_size: Integer(U64), value: 62 }, Const { destination: Relative(5), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 54 }, Jump { location: 101 }, Const { destination: Relative(7), bit_size: Integer(U64), value: 64 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U64, lhs: Relative(1), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 58 }, Jump { location: 98 }, Const { destination: Relative(8), bit_size: Integer(U64), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U64), value: 2 }, Const { destination: Relative(10), bit_size: Integer(U64), value: 1 }, Cast { destination: Relative(11), source: Relative(1), bit_size: Integer(U32) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 69 }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U64, lhs: Relative(10), rhs: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Jump { location: 63 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(8) }, Const { destination: Relative(17), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U64, lhs: Relative(17), rhs: Relative(3) }, Const { destination: Relative(18), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U64, lhs: Relative(18), rhs: Relative(3) }, JumpIf { condition: Relative(12), location: 76 }, Jump { location: 78 }, Mov { destination: Relative(13), source: Relative(19) }, Jump { location: 80 }, Mov { destination: Relative(13), source: Relative(3) }, Jump { location: 80 }, Const { destination: Relative(17), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U64, lhs: Relative(17), rhs: Relative(10) }, Const { destination: Relative(18), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U64, lhs: Relative(18), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 86 }, Jump { location: 88 }, Mov { destination: Relative(15), source: Relative(19) }, Jump { location: 90 }, Mov { destination: Relative(15), source: Relative(10) }, Jump { location: 90 }, BinaryIntOp { destination: Relative(3), op: Div, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: Xor, bit_size: U1, lhs: Relative(12), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 94 }, Jump { location: 96 }, Const { destination: Relative(17), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U64, lhs: Relative(17), rhs: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U64, lhs: Relative(3), rhs: Relative(8) }, Jump { location: 100 }, Const { destination: Relative(3), bit_size: Integer(U64), value: 18446744073709551615 }, Jump { location: 100 }, Jump { location: 103 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U64, lhs: Relative(2), rhs: Relative(1) }, Jump { location: 103 }, Mov { destination: Relative(1), source: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 18446744073709551615 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 109 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 115 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pdTLjqpAFEDRf6kxg3o/+JWOMajYISFoaL3JjfHf++AG2x70BCfuKvEsDSm5qUO7u35uu+F4+lL1x03txq7vu89tf9o3l+40yLs3pacXE1RtKmUiSaq2kkzKI1YTQ6yqncQRr2ovCSSSRDIRJVTKaSJKlFjiiCeBiJIkomRJJuURr4khljjiSSCRoHgUL0qpVNDEEEsc8SSQSBLJBCWiRJSIElEiSkSJKBElokSUhJJQEkpCSSgJJaEklISSUDJKRskoGSWjZJSMklEySkYpKAWloBSUglJQCkpBKSgFxWg918wVyOhp4ZaFXxZhWUwHUN/vlVrO6PYytu10RF8OrRzlczO2w0XVw7XvK/Wv6a+PD32dm+HRSzPKVSHb4SAV8Nj17bS6Vz/T+u9R69w8bF15joc18z6umY/Lj7fxzflkV8w7l+Z55/2b82vuX3jev+DNqnnznLdvzuf35sPv+7eRXbPvxl+P4fskjV2z69t5e7wO+5erl//n5cryGD+Pp317uI7tJL08y+X1w+hcGeM28p8y09Z42cbNffr6bw==", + "debug_symbols": "pdRNjoJAEIbhu/SaRf9WV3OViTGorSEhaBAmmRjuPgUfOLqYDW54G7EeDWl4qFM+DJd93Z6vd1V+PdShq5umvuyb67Hq62srnz6Ung4mqNIUyhASVWkljKQ5ViMGsap0Eod4VXpJQAiJCCOihEI5jYhCEos4xCMBESVKRGEJI2mO14hBLOIQjwSEECgeihclFSpoxCAWcYhHAkJIRBiBQlAICkEhKASFoBAUgkJQCEqEEqFEKBFKhBKhRCgRSoQSoTAUhsJQGApDYSgMhaEwFIaSoCQoCUqCkqAkKAlKgpKgJChG66VmqV3qlgpl9LQI64LWRVwXPC3GsVDrnt33Xc7Tln3ZxLK1b1WX216V7dA0hfqummH+0v1WtXP7qpOrQub2JBXwXDd5Wo3F37T+f9Q6twxbl57jYcu8py3ztP55Sx/OR7th3rm4zDvvP5zfcv/C8/4FbzbNm+e8/XCeP5sP7/dvJ2fVse7eXsvjJHV1dWjycnoe2uPL1f7ntl5ZX+u37nrMp6HLk/Tybpfjl5HHyZiwk2fKzKckp7wbp5//BQ==", "file_map": { "50": { - "source": "fn main(x: u64) {\n let two: u64 = 2;\n let three: u64 = 3;\n // shifts on constant values\n assert(two << 2 == 8);\n assert((two << 3) / 8 == two);\n assert((three >> 1) == 1);\n // shifts on runtime values\n assert(x << 1 == 128);\n assert(x >> 2 == 16);\n\n regression_2250();\n\n //regression for 3481\n assert(x << 63 == 0);\n\n assert_eq(1_u64 << 32, 0x0100000000);\n\n //regression for 6201\n let a: i16 = -769;\n assert_eq(a >> 3, -97);\n\n regression_8310();\n\n //regression 8791\n assert(-(x as i64) >> 63 == -1);\n assert(a >> 27 == -1);\n}\n\nfn regression_2250() {\n let a: u1 = 1 >> 1;\n assert(a == 0);\n\n let b: u32 = 1 >> 32;\n assert(b == 0);\n}\n\nfn regression_8310() {\n let x: i64 = -356710612598522715;\n let b = x >> 64;\n assert(b == -1);\n}\n", + "source": "fn main(x: u64) {\n let two: u64 = 2;\n let three: u64 = 3;\n // shifts on constant values\n assert(two << 2 == 8);\n assert((two << 3) / 8 == two);\n assert((three >> 1) == 1);\n // shifts on runtime values\n assert(x << 1 == 128);\n assert(x >> 2 == 16);\n\n regression_2250();\n\n //regression for 3481\n assert(x << 63 == 0);\n\n assert_eq(1_u64 << 32, 0x0100000000);\n\n //regression for 6201\n let a: i16 = -769;\n assert_eq(a >> 3, -97);\n\n regression_8310();\n\n //regression 8791\n assert(-(x as i64) >> 62 == -1);\n assert(a >> 14 == -1);\n}\n\nfn regression_2250() {\n let b: u32 = 1 >> 31;\n assert(b == 0);\n}\n\nfn regression_8310() {\n let x: i64 = -356710612598522715;\n let b = x >> 62;\n assert(b == -1);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_true_inliner_0.snap index 1fcb4d74447..a337590c379 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_true_inliner_0.snap @@ -37,12 +37,12 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U64) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 108 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 128 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 22 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(2), bit_size: Integer(U8), value: 2 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 16 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 29 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(2), bit_size: Integer(U8), value: 63 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 36 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Cast { destination: Relative(3), source: Relative(1), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U64, lhs: Relative(4), rhs: Relative(3) }, Mov { destination: Relative(3), source: Relative(5) }, Cast { destination: Relative(4), source: Relative(3), bit_size: Integer(U64) }, Const { destination: Relative(5), bit_size: Integer(U64), value: 9223372036854775808 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U64, lhs: Relative(1), rhs: Relative(5) }, Not { destination: Relative(1), source: Relative(6), bit_size: U1 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Mul, bit_size: U1, lhs: Relative(6), rhs: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 49 }, Call { location: 114 }, Const { destination: Relative(5), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U64, lhs: Relative(5), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 53 }, Jump { location: 100 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 64 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 57 }, Jump { location: 97 }, Const { destination: Relative(8), bit_size: Integer(U64), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U64), value: 2 }, Const { destination: Relative(10), bit_size: Integer(U64), value: 1 }, Cast { destination: Relative(11), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 68 }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U64, lhs: Relative(10), rhs: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Jump { location: 62 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U64, lhs: Relative(3), rhs: Relative(8) }, Const { destination: Relative(17), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U64, lhs: Relative(17), rhs: Relative(1) }, Const { destination: Relative(18), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U64, lhs: Relative(18), rhs: Relative(1) }, JumpIf { condition: Relative(12), location: 75 }, Jump { location: 77 }, Mov { destination: Relative(13), source: Relative(19) }, Jump { location: 79 }, Mov { destination: Relative(13), source: Relative(1) }, Jump { location: 79 }, Const { destination: Relative(17), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U64, lhs: Relative(17), rhs: Relative(10) }, Const { destination: Relative(18), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U64, lhs: Relative(18), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 85 }, Jump { location: 87 }, Mov { destination: Relative(15), source: Relative(19) }, Jump { location: 89 }, Mov { destination: Relative(15), source: Relative(10) }, Jump { location: 89 }, BinaryIntOp { destination: Relative(1), op: Div, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: Xor, bit_size: U1, lhs: Relative(12), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 93 }, Jump { location: 95 }, Const { destination: Relative(17), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U64, lhs: Relative(17), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U64, lhs: Relative(1), rhs: Relative(8) }, Jump { location: 99 }, Const { destination: Relative(1), bit_size: Integer(U64), value: 18446744073709551615 }, Jump { location: 99 }, Jump { location: 102 }, BinaryIntOp { destination: Relative(1), op: Shr, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, Jump { location: 102 }, Const { destination: Relative(2), bit_size: Integer(U64), value: 18446744073709551615 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 107 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 113 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U64) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 110 }, Const { destination: Relative(2), bit_size: Integer(U64), value: 1 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 128 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 22 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(2), bit_size: Integer(U64), value: 2 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 16 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 29 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(2), bit_size: Integer(U64), value: 63 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 36 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Cast { destination: Relative(2), source: Relative(1), bit_size: Integer(U64) }, Const { destination: Relative(3), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, Mov { destination: Relative(2), source: Relative(4) }, Cast { destination: Relative(3), source: Relative(2), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 9223372036854775808 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U64, lhs: Relative(1), rhs: Relative(4) }, Not { destination: Relative(1), source: Relative(5), bit_size: U1 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 49 }, Call { location: 116 }, Const { destination: Relative(1), bit_size: Integer(U64), value: 62 }, Const { destination: Relative(5), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 54 }, Jump { location: 101 }, Const { destination: Relative(7), bit_size: Integer(U64), value: 64 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U64, lhs: Relative(1), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 58 }, Jump { location: 98 }, Const { destination: Relative(8), bit_size: Integer(U64), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U64), value: 2 }, Const { destination: Relative(10), bit_size: Integer(U64), value: 1 }, Cast { destination: Relative(11), source: Relative(1), bit_size: Integer(U32) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 69 }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U64, lhs: Relative(10), rhs: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Jump { location: 63 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(8) }, Const { destination: Relative(17), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U64, lhs: Relative(17), rhs: Relative(3) }, Const { destination: Relative(18), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U64, lhs: Relative(18), rhs: Relative(3) }, JumpIf { condition: Relative(12), location: 76 }, Jump { location: 78 }, Mov { destination: Relative(13), source: Relative(19) }, Jump { location: 80 }, Mov { destination: Relative(13), source: Relative(3) }, Jump { location: 80 }, Const { destination: Relative(17), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U64, lhs: Relative(17), rhs: Relative(10) }, Const { destination: Relative(18), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U64, lhs: Relative(18), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 86 }, Jump { location: 88 }, Mov { destination: Relative(15), source: Relative(19) }, Jump { location: 90 }, Mov { destination: Relative(15), source: Relative(10) }, Jump { location: 90 }, BinaryIntOp { destination: Relative(3), op: Div, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: Xor, bit_size: U1, lhs: Relative(12), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 94 }, Jump { location: 96 }, Const { destination: Relative(17), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U64, lhs: Relative(17), rhs: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U64, lhs: Relative(3), rhs: Relative(8) }, Jump { location: 100 }, Const { destination: Relative(3), bit_size: Integer(U64), value: 18446744073709551615 }, Jump { location: 100 }, Jump { location: 103 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U64, lhs: Relative(2), rhs: Relative(1) }, Jump { location: 103 }, Mov { destination: Relative(1), source: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 18446744073709551615 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 109 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 115 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pdTLjqpAFEDRf6kxg3o/+JWOMajYISFoaL3JjfHf++AG2x70BCfuKvEsDSm5qUO7u35uu+F4+lL1x03txq7vu89tf9o3l+40yLs3pacXE1RtKmUiSaq2kkzKI1YTQ6yqncQRr2ovCSSSRDIRJVTKaSJKlFjiiCeBiJIkomRJJuURr4khljjiSSCRoHgUL0qpVNDEEEsc8SSQSBLJBCWiRJSIElEiSkSJKBElokSUhJJQEkpCSSgJJaEklISSUDJKRskoGSWjZJSMklEySkYpKAWloBSUglJQCkpBKSgFxWg918wVyOhp4ZaFXxZhWUwHUN/vlVrO6PYytu10RF8OrRzlczO2w0XVw7XvK/Wv6a+PD32dm+HRSzPKVSHb4SAV8Nj17bS6Vz/T+u9R69w8bF15joc18z6umY/Lj7fxzflkV8w7l+Z55/2b82vuX3jev+DNqnnznLdvzuf35sPv+7eRXbPvxl+P4fskjV2z69t5e7wO+5erl//n5cryGD+Pp317uI7tJL08y+X1w+hcGeM28p8y09Z42cbNffr6bw==", + "debug_symbols": "pdRNjoJAEIbhu/SaRf9WV3OViTGorSEhaBAmmRjuPgUfOLqYDW54G7EeDWl4qFM+DJd93Z6vd1V+PdShq5umvuyb67Hq62srnz6Ung4mqNIUyhASVWkljKQ5ViMGsap0Eod4VXpJQAiJCCOihEI5jYhCEos4xCMBESVKRGEJI2mO14hBLOIQjwSEECgeihclFSpoxCAWcYhHAkJIRBiBQlAICkEhKASFoBAUgkJQCEqEEqFEKBFKhBKhRCgRSoQSoTAUhsJQGApDYSgMhaEwFIaSoCQoCUqCkqAkKAlKgpKgJChG66VmqV3qlgpl9LQI64LWRVwXPC3GsVDrnt33Xc7Tln3ZxLK1b1WX216V7dA0hfqummH+0v1WtXP7qpOrQub2JBXwXDd5Wo3F37T+f9Q6twxbl57jYcu8py3ztP55Sx/OR7th3rm4zDvvP5zfcv/C8/4FbzbNm+e8/XCeP5sP7/dvJ2fVse7eXsvjJHV1dWjycnoe2uPL1f7ntl5ZX+u37nrMp6HLk/Tybpfjl5HHyZiwk2fKzKckp7wbp5//BQ==", "file_map": { "50": { - "source": "fn main(x: u64) {\n let two: u64 = 2;\n let three: u64 = 3;\n // shifts on constant values\n assert(two << 2 == 8);\n assert((two << 3) / 8 == two);\n assert((three >> 1) == 1);\n // shifts on runtime values\n assert(x << 1 == 128);\n assert(x >> 2 == 16);\n\n regression_2250();\n\n //regression for 3481\n assert(x << 63 == 0);\n\n assert_eq(1_u64 << 32, 0x0100000000);\n\n //regression for 6201\n let a: i16 = -769;\n assert_eq(a >> 3, -97);\n\n regression_8310();\n\n //regression 8791\n assert(-(x as i64) >> 63 == -1);\n assert(a >> 27 == -1);\n}\n\nfn regression_2250() {\n let a: u1 = 1 >> 1;\n assert(a == 0);\n\n let b: u32 = 1 >> 32;\n assert(b == 0);\n}\n\nfn regression_8310() {\n let x: i64 = -356710612598522715;\n let b = x >> 64;\n assert(b == -1);\n}\n", + "source": "fn main(x: u64) {\n let two: u64 = 2;\n let three: u64 = 3;\n // shifts on constant values\n assert(two << 2 == 8);\n assert((two << 3) / 8 == two);\n assert((three >> 1) == 1);\n // shifts on runtime values\n assert(x << 1 == 128);\n assert(x >> 2 == 16);\n\n regression_2250();\n\n //regression for 3481\n assert(x << 63 == 0);\n\n assert_eq(1_u64 << 32, 0x0100000000);\n\n //regression for 6201\n let a: i16 = -769;\n assert_eq(a >> 3, -97);\n\n regression_8310();\n\n //regression 8791\n assert(-(x as i64) >> 62 == -1);\n assert(a >> 14 == -1);\n}\n\nfn regression_2250() {\n let b: u32 = 1 >> 31;\n assert(b == 0);\n}\n\nfn regression_8310() {\n let x: i64 = -356710612598522715;\n let b = x >> 62;\n assert(b == -1);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 1fcb4d74447..a337590c379 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_comptime/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -37,12 +37,12 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U64) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 108 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 128 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 22 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(2), bit_size: Integer(U8), value: 2 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 16 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 29 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(2), bit_size: Integer(U8), value: 63 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 36 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Cast { destination: Relative(3), source: Relative(1), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U64, lhs: Relative(4), rhs: Relative(3) }, Mov { destination: Relative(3), source: Relative(5) }, Cast { destination: Relative(4), source: Relative(3), bit_size: Integer(U64) }, Const { destination: Relative(5), bit_size: Integer(U64), value: 9223372036854775808 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U64, lhs: Relative(1), rhs: Relative(5) }, Not { destination: Relative(1), source: Relative(6), bit_size: U1 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Mul, bit_size: U1, lhs: Relative(6), rhs: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 49 }, Call { location: 114 }, Const { destination: Relative(5), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U64, lhs: Relative(5), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 53 }, Jump { location: 100 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 64 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 57 }, Jump { location: 97 }, Const { destination: Relative(8), bit_size: Integer(U64), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U64), value: 2 }, Const { destination: Relative(10), bit_size: Integer(U64), value: 1 }, Cast { destination: Relative(11), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 68 }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U64, lhs: Relative(10), rhs: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Jump { location: 62 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U64, lhs: Relative(3), rhs: Relative(8) }, Const { destination: Relative(17), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U64, lhs: Relative(17), rhs: Relative(1) }, Const { destination: Relative(18), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U64, lhs: Relative(18), rhs: Relative(1) }, JumpIf { condition: Relative(12), location: 75 }, Jump { location: 77 }, Mov { destination: Relative(13), source: Relative(19) }, Jump { location: 79 }, Mov { destination: Relative(13), source: Relative(1) }, Jump { location: 79 }, Const { destination: Relative(17), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U64, lhs: Relative(17), rhs: Relative(10) }, Const { destination: Relative(18), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U64, lhs: Relative(18), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 85 }, Jump { location: 87 }, Mov { destination: Relative(15), source: Relative(19) }, Jump { location: 89 }, Mov { destination: Relative(15), source: Relative(10) }, Jump { location: 89 }, BinaryIntOp { destination: Relative(1), op: Div, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: Xor, bit_size: U1, lhs: Relative(12), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 93 }, Jump { location: 95 }, Const { destination: Relative(17), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U64, lhs: Relative(17), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U64, lhs: Relative(1), rhs: Relative(8) }, Jump { location: 99 }, Const { destination: Relative(1), bit_size: Integer(U64), value: 18446744073709551615 }, Jump { location: 99 }, Jump { location: 102 }, BinaryIntOp { destination: Relative(1), op: Shr, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, Jump { location: 102 }, Const { destination: Relative(2), bit_size: Integer(U64), value: 18446744073709551615 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 107 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 113 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U64) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 110 }, Const { destination: Relative(2), bit_size: Integer(U64), value: 1 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 128 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 22 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(2), bit_size: Integer(U64), value: 2 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 16 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 29 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(2), bit_size: Integer(U64), value: 63 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 36 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Cast { destination: Relative(2), source: Relative(1), bit_size: Integer(U64) }, Const { destination: Relative(3), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, Mov { destination: Relative(2), source: Relative(4) }, Cast { destination: Relative(3), source: Relative(2), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 9223372036854775808 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U64, lhs: Relative(1), rhs: Relative(4) }, Not { destination: Relative(1), source: Relative(5), bit_size: U1 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 49 }, Call { location: 116 }, Const { destination: Relative(1), bit_size: Integer(U64), value: 62 }, Const { destination: Relative(5), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 54 }, Jump { location: 101 }, Const { destination: Relative(7), bit_size: Integer(U64), value: 64 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U64, lhs: Relative(1), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 58 }, Jump { location: 98 }, Const { destination: Relative(8), bit_size: Integer(U64), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U64), value: 2 }, Const { destination: Relative(10), bit_size: Integer(U64), value: 1 }, Cast { destination: Relative(11), source: Relative(1), bit_size: Integer(U32) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 69 }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U64, lhs: Relative(10), rhs: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Jump { location: 63 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(8) }, Const { destination: Relative(17), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U64, lhs: Relative(17), rhs: Relative(3) }, Const { destination: Relative(18), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U64, lhs: Relative(18), rhs: Relative(3) }, JumpIf { condition: Relative(12), location: 76 }, Jump { location: 78 }, Mov { destination: Relative(13), source: Relative(19) }, Jump { location: 80 }, Mov { destination: Relative(13), source: Relative(3) }, Jump { location: 80 }, Const { destination: Relative(17), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U64, lhs: Relative(17), rhs: Relative(10) }, Const { destination: Relative(18), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U64, lhs: Relative(18), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 86 }, Jump { location: 88 }, Mov { destination: Relative(15), source: Relative(19) }, Jump { location: 90 }, Mov { destination: Relative(15), source: Relative(10) }, Jump { location: 90 }, BinaryIntOp { destination: Relative(3), op: Div, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: Xor, bit_size: U1, lhs: Relative(12), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 94 }, Jump { location: 96 }, Const { destination: Relative(17), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U64, lhs: Relative(17), rhs: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U64, lhs: Relative(3), rhs: Relative(8) }, Jump { location: 100 }, Const { destination: Relative(3), bit_size: Integer(U64), value: 18446744073709551615 }, Jump { location: 100 }, Jump { location: 103 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U64, lhs: Relative(2), rhs: Relative(1) }, Jump { location: 103 }, Mov { destination: Relative(1), source: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 18446744073709551615 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 109 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 115 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pdTLjqpAFEDRf6kxg3o/+JWOMajYISFoaL3JjfHf++AG2x70BCfuKvEsDSm5qUO7u35uu+F4+lL1x03txq7vu89tf9o3l+40yLs3pacXE1RtKmUiSaq2kkzKI1YTQ6yqncQRr2ovCSSSRDIRJVTKaSJKlFjiiCeBiJIkomRJJuURr4khljjiSSCRoHgUL0qpVNDEEEsc8SSQSBLJBCWiRJSIElEiSkSJKBElokSUhJJQEkpCSSgJJaEklISSUDJKRskoGSWjZJSMklEySkYpKAWloBSUglJQCkpBKSgFxWg918wVyOhp4ZaFXxZhWUwHUN/vlVrO6PYytu10RF8OrRzlczO2w0XVw7XvK/Wv6a+PD32dm+HRSzPKVSHb4SAV8Nj17bS6Vz/T+u9R69w8bF15joc18z6umY/Lj7fxzflkV8w7l+Z55/2b82vuX3jev+DNqnnznLdvzuf35sPv+7eRXbPvxl+P4fskjV2z69t5e7wO+5erl//n5cryGD+Pp317uI7tJL08y+X1w+hcGeM28p8y09Z42cbNffr6bw==", + "debug_symbols": "pdRNjoJAEIbhu/SaRf9WV3OViTGorSEhaBAmmRjuPgUfOLqYDW54G7EeDWl4qFM+DJd93Z6vd1V+PdShq5umvuyb67Hq62srnz6Ung4mqNIUyhASVWkljKQ5ViMGsap0Eod4VXpJQAiJCCOihEI5jYhCEos4xCMBESVKRGEJI2mO14hBLOIQjwSEECgeihclFSpoxCAWcYhHAkJIRBiBQlAICkEhKASFoBAUgkJQCEqEEqFEKBFKhBKhRCgRSoQSoTAUhsJQGApDYSgMhaEwFIaSoCQoCUqCkqAkKAlKgpKgJChG66VmqV3qlgpl9LQI64LWRVwXPC3GsVDrnt33Xc7Tln3ZxLK1b1WX216V7dA0hfqummH+0v1WtXP7qpOrQub2JBXwXDd5Wo3F37T+f9Q6twxbl57jYcu8py3ztP55Sx/OR7th3rm4zDvvP5zfcv/C8/4FbzbNm+e8/XCeP5sP7/dvJ2fVse7eXsvjJHV1dWjycnoe2uPL1f7ntl5ZX+u37nrMp6HLk/Tybpfjl5HHyZiwk2fKzKckp7wbp5//BQ==", "file_map": { "50": { - "source": "fn main(x: u64) {\n let two: u64 = 2;\n let three: u64 = 3;\n // shifts on constant values\n assert(two << 2 == 8);\n assert((two << 3) / 8 == two);\n assert((three >> 1) == 1);\n // shifts on runtime values\n assert(x << 1 == 128);\n assert(x >> 2 == 16);\n\n regression_2250();\n\n //regression for 3481\n assert(x << 63 == 0);\n\n assert_eq(1_u64 << 32, 0x0100000000);\n\n //regression for 6201\n let a: i16 = -769;\n assert_eq(a >> 3, -97);\n\n regression_8310();\n\n //regression 8791\n assert(-(x as i64) >> 63 == -1);\n assert(a >> 27 == -1);\n}\n\nfn regression_2250() {\n let a: u1 = 1 >> 1;\n assert(a == 0);\n\n let b: u32 = 1 >> 32;\n assert(b == 0);\n}\n\nfn regression_8310() {\n let x: i64 = -356710612598522715;\n let b = x >> 64;\n assert(b == -1);\n}\n", + "source": "fn main(x: u64) {\n let two: u64 = 2;\n let three: u64 = 3;\n // shifts on constant values\n assert(two << 2 == 8);\n assert((two << 3) / 8 == two);\n assert((three >> 1) == 1);\n // shifts on runtime values\n assert(x << 1 == 128);\n assert(x >> 2 == 16);\n\n regression_2250();\n\n //regression for 3481\n assert(x << 63 == 0);\n\n assert_eq(1_u64 << 32, 0x0100000000);\n\n //regression for 6201\n let a: i16 = -769;\n assert_eq(a >> 3, -97);\n\n regression_8310();\n\n //regression 8791\n assert(-(x as i64) >> 62 == -1);\n assert(a >> 14 == -1);\n}\n\nfn regression_2250() {\n let b: u32 = 1 >> 31;\n assert(b == 0);\n}\n\nfn regression_8310() {\n let x: i64 = -356710612598522715;\n let b = x >> 62;\n assert(b == -1);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__expanded.snap index 58ef7ba0600..6d707eea78d 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__expanded.snap @@ -2,23 +2,28 @@ source: tooling/nargo_cli/tests/execute.rs expression: expanded_code --- -fn main(x: u64, y: u8, z: i16, u: i64) { - assert((64_u32 << y) == 128_u32); - assert((64_u32 >> y) == 32_u32); +fn main(x: u64, y: u64, z: i16, u: i64) { + assert((64_u64 << y) == 128_u64); + assert((64_u64 >> y) == 32_u64); assert((x << y) == 128_u64); assert((x >> y) == 32_u64); - assert((u >> (x as u8)) == -1_i64); - assert((z >> (x as u8)) == -1_i16); + assert((u >> ((x as i64) - 2_i64)) == -1_i64); let mut a: i8 = y as i8; let mut b: i8 = x as i8; - assert((b << 1_u8) == -128_i8); - assert((b >> 2_u8) == 16_i8); - assert((b >> y) == 32_i8); + assert((b << 1_i8) == -128_i8); + assert((b >> 2_i8) == 16_i8); + assert((b >> a) == 32_i8); a = -a; - assert((a << 7_u8) == -128_i8); - assert((a << y) == -2_i8); - assert((x >> (x as u8)) == 0_u64); - assert((z >> 3_u8) == -97_i16); - assert((z >> 16_u8) == -1_i16); - assert((-z >> (x as u8)) == 0_i16); + assert((a << 6_i8) == -64_i8); + assert((a << -a) == -2_i8); + assert((x >> (x - 1_u64)) == 0_u64); + assert((z >> 3_i16) == -97_i16); + assert((z >> 14_i16) == -1_i16); + let rhs: i16 = if (x as i16) > 14_i16 { + 14_i16 + } else { + x as i16 + }; + assert((z >> rhs) == -1_i16); + assert((-z >> rhs) == 0_i16); } diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 1767192b8eb..7755aac6b8a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -21,7 +21,7 @@ expression: artifact "type": { "kind": "integer", "sign": "unsigned", - "width": 8 + "width": 64 }, "visibility": "private" }, @@ -50,31 +50,39 @@ expression: artifact "error_kind": "string", "string": "attempt to subtract with overflow" }, - "5795655218219125583": { + "6668324276689745315": { + "error_kind": "string", + "string": "Field failed to decompose into specified 4 limbs" + }, + "13958753312450585022": { "error_kind": "string", - "string": "Field failed to decompose into specified 8 limbs" + "string": "Field failed to decompose into specified 7 limbs" }, "14514982005979867414": { "error_kind": "string", "string": "attempt to bit-shift with overflow" + }, + "16061458491050355795": { + "error_kind": "string", + "string": "Field failed to decompose into specified 5 limbs" } } }, "bytecode": [ "func 0", - "current witness index : _416", + "current witness index : _489", "private parameters indices : [_0, _1, _2, _3]", "public parameters indices : []", "return value indices : []", "BLACKBOX::RANGE [(_0, 64)] []", - "BLACKBOX::RANGE [(_1, 8)] []", + "BLACKBOX::RANGE [(_1, 64)] []", "BLACKBOX::RANGE [(_2, 16)] []", "BLACKBOX::RANGE [(_3, 64)] []", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 224 ], EXPR [ 256 ]], outputs: [_4, _5]", - "BLACKBOX::RANGE [(_4, 1)] []", - "BLACKBOX::RANGE [(_5, 8)] []", - "EXPR [ (1, _1) (-256, _4) (-1, _5) 224 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_6, _7, _8, _9, _10, _11, _12, _13]]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 18446744073709551552 ], EXPR [ 18446744073709551616 ]], outputs: [_4, _5]", + "BLACKBOX::RANGE [(_5, 64)] []", + "EXPR [ (1, _1) (-18446744073709551616, _4) (-1, _5) 18446744073709551552 ]", + "EXPR [ (-1, _4) 0 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1) 0 ], EXPR [ 7 ], EXPR [ 2 ]], outputs: [[_6, _7, _8, _9, _10, _11, _12]]", "BLACKBOX::RANGE [(_6, 1)] []", "BLACKBOX::RANGE [(_7, 1)] []", "BLACKBOX::RANGE [(_8, 1)] []", @@ -82,112 +90,121 @@ expression: artifact "BLACKBOX::RANGE [(_10, 1)] []", "BLACKBOX::RANGE [(_11, 1)] []", "BLACKBOX::RANGE [(_12, 1)] []", - "BLACKBOX::RANGE [(_13, 1)] []", - "EXPR [ (1, _1) (-1, _6) (-2, _7) (-4, _8) (-8, _9) (-16, _10) (-32, _11) (-64, _12) (-128, _13) 0 ]", - "EXPR [ (1, _13, _13) (2, _13) (-1, _14) 1 ]", - "EXPR [ (-1, _12) (-1, _15) 1 ]", - "EXPR [ (2, _12, _14) (1, _14, _15) (-1, _16) 0 ]", - "EXPR [ (1, _16, _16) (-1, _17) 0 ]", - "EXPR [ (-1, _11) (-1, _18) 1 ]", - "EXPR [ (2, _11, _17) (1, _17, _18) (-1, _19) 0 ]", - "EXPR [ (1, _19, _19) (-1, _20) 0 ]", - "EXPR [ (-1, _10) (-1, _21) 1 ]", - "EXPR [ (2, _10, _20) (1, _20, _21) (-1, _22) 0 ]", - "EXPR [ (1, _22, _22) (-1, _23) 0 ]", - "EXPR [ (-1, _9) (-1, _24) 1 ]", - "EXPR [ (2, _9, _23) (1, _23, _24) (-1, _25) 0 ]", - "EXPR [ (1, _25, _25) (-1, _26) 0 ]", - "EXPR [ (-1, _8) (-1, _27) 1 ]", - "EXPR [ (2, _8, _26) (1, _26, _27) (-1, _28) 0 ]", - "EXPR [ (1, _28, _28) (-1, _29) 0 ]", - "EXPR [ (-1, _7) (-1, _30) 1 ]", - "EXPR [ (2, _7, _29) (1, _29, _30) (-1, _31) 0 ]", - "EXPR [ (1, _31, _31) (-1, _32) 0 ]", - "EXPR [ (-1, _6) (-1, _33) 1 ]", - "EXPR [ (-1, _4) (-1, _34) 1 ]", - "EXPR [ (2, _6, _32) (1, _32, _33) (-1, _35) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (64, _34, _35) 0 ], EXPR [ 4294967296 ]], outputs: [_36, _37]", - "BLACKBOX::RANGE [(_36, 222)] []", - "EXPR [ (64, _34, _35) (-4294967296, _36) (-1, _37) 0 ]", - "EXPR [ (-1, _36) (-1, _38) 5096253676302562286669017222071363378443840053029366383258766538131 ]", - "BLACKBOX::RANGE [(_38, 222)] []", - "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _36) 5096253676302562286669017222071363378443840053029366383258766538131 ]], outputs: [_39]", - "EXPR [ (-1, _36, _39) (5096253676302562286669017222071363378443840053029366383258766538131, _39) (1, _40) -1 ]", - "EXPR [ (-1, _36, _40) (5096253676302562286669017222071363378443840053029366383258766538131, _40) 0 ]", - "EXPR [ (1, _37, _40) (268435455, _40) (-1, _41) 0 ]", - "BLACKBOX::RANGE [(_41, 32)] []", - "EXPR [ (1, _34) -1 ]", - "EXPR [ (1, _37) -128 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _35) 0 ]], outputs: [_42]", - "EXPR [ (1, _35, _42) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ 64 ], EXPR [ (1, _35) 0 ]], outputs: [_43, _44]", - "BLACKBOX::RANGE [(_44, 32)] []", - "EXPR [ (1, _35) (-1, _44) (-1, _45) -1 ]", - "BLACKBOX::RANGE [(_45, 32)] []", - "EXPR [ (-1, _35, _43) (-1, _44) 64 ]", - "EXPR [ (1, _43) -32 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 192 ], EXPR [ 256 ]], outputs: [_46, _47]", - "BLACKBOX::RANGE [(_47, 8)] []", - "EXPR [ (1, _1) (-256, _46) (-1, _47) 192 ]", - "EXPR [ (-1, _35, _46) (1, _35) (-1, _48) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0, _48) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_49, _50]", - "BLACKBOX::RANGE [(_49, 190)] []", - "EXPR [ (1, _0, _48) (-18446744073709551616, _49) (-1, _50) 0 ]", - "EXPR [ (-1, _49) (-1, _51) 1186564023676924939888766319973246049704924238154051448977 ]", - "BLACKBOX::RANGE [(_51, 190)] []", - "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _49) 1186564023676924939888766319973246049704924238154051448977 ]], outputs: [_52]", - "EXPR [ (-1, _49, _52) (1186564023676924939888766319973246049704924238154051448977, _52) (1, _53) -1 ]", - "EXPR [ (-1, _49, _53) (1186564023676924939888766319973246049704924238154051448977, _53) 0 ]", - "EXPR [ (1, _50, _53) (4331911350818177023, _53) (-1, _54) 0 ]", - "BLACKBOX::RANGE [(_54, 63)] []", - "EXPR [ (-1, _46) 0 ]", - "EXPR [ (1, _50) -128 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _35) 0 ]], outputs: [_55]", - "EXPR [ (1, _35, _55) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _35) 0 ]], outputs: [_56, _57]", - "BLACKBOX::RANGE [(_57, 64)] []", - "EXPR [ (1, _35) (-1, _57) (-1, _58) -1 ]", - "BLACKBOX::RANGE [(_58, 64)] []", - "EXPR [ (-1, _35, _56) (1, _0) (-1, _57) 0 ]", - "EXPR [ (1, _56) -32 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 256 ]], outputs: [_59, _60]", - "BLACKBOX::RANGE [(_59, 56)] []", - "BLACKBOX::RANGE [(_60, 8)] []", - "EXPR [ (1, _0) (-256, _59) (-1, _60) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _60) 192 ], EXPR [ 256 ]], outputs: [_61, _62]", - "BLACKBOX::RANGE [(_61, 1)] []", - "BLACKBOX::RANGE [(_62, 8)] []", - "EXPR [ (1, _60) (-256, _61) (-1, _62) 192 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _61, _60) (1, _60) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_63, _64, _65, _66, _67, _68, _69, _70]]", - "BLACKBOX::RANGE [(_63, 1)] []", + "EXPR [ (1, _1) (-1, _6) (-2, _7) (-4, _8) (-8, _9) (-16, _10) (-32, _11) (-64, _12) 0 ]", + "EXPR [ (1, _12, _12) (2, _12) (-1, _13) 1 ]", + "EXPR [ (-1, _11) (-1, _14) 1 ]", + "EXPR [ (2, _11, _13) (1, _13, _14) (-1, _15) 0 ]", + "EXPR [ (1, _15, _15) (-1, _16) 0 ]", + "EXPR [ (-1, _10) (-1, _17) 1 ]", + "EXPR [ (2, _10, _16) (1, _16, _17) (-1, _18) 0 ]", + "EXPR [ (1, _18, _18) (-1, _19) 0 ]", + "EXPR [ (-1, _9) (-1, _20) 1 ]", + "EXPR [ (2, _9, _19) (1, _19, _20) (-1, _21) 0 ]", + "EXPR [ (1, _21, _21) (-1, _22) 0 ]", + "EXPR [ (-1, _8) (-1, _23) 1 ]", + "EXPR [ (2, _8, _22) (1, _22, _23) (-1, _24) 0 ]", + "EXPR [ (1, _24, _24) (-1, _25) 0 ]", + "EXPR [ (-1, _7) (-1, _26) 1 ]", + "EXPR [ (2, _7, _25) (1, _25, _26) (-1, _27) 0 ]", + "EXPR [ (1, _27, _27) (-1, _28) 0 ]", + "EXPR [ (-1, _6) (-1, _29) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (128, _28, _6) (64, _28, _29) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_30, _31]", + "BLACKBOX::RANGE [(_30, 190)] []", + "EXPR [ (128, _6, _28) (-1, _411) 0 ]", + "EXPR [ (64, _28, _29) (-1, _412) 0 ]", + "EXPR [ (-18446744073709551616, _30) (-1, _31) (1, _411) (1, _412) 0 ]", + "EXPR [ (-1, _30) (-1, _32) 1186564023676924939888766319973246049704924238154051448977 ]", + "BLACKBOX::RANGE [(_32, 190)] []", + "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _30) 1186564023676924939888766319973246049704924238154051448977 ]], outputs: [_33]", + "EXPR [ (-1, _30, _33) (1186564023676924939888766319973246049704924238154051448977, _33) (1, _34) -1 ]", + "EXPR [ (-1, _30, _34) (1186564023676924939888766319973246049704924238154051448977, _34) 0 ]", + "EXPR [ (1, _31, _34) (4331911350818177023, _34) (-1, _35) 0 ]", + "BLACKBOX::RANGE [(_35, 63)] []", + "EXPR [ (1, _31) -128 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _28, _6) (1, _28, _29) 0 ]], outputs: [_36]", + "EXPR [ (-1, _37) (-342003794872488675347600089769644923258568193756500536620284440415247007744, _411) (-342003794872488675347600089769644923258568193756500536620284440415247007744, _412) 0 ]", + "EXPR [ (1, _36, _37) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ 64 ], EXPR [ (1, _37) 0 ]], outputs: [_38, _39]", + "BLACKBOX::RANGE [(_39, 64)] []", + "EXPR [ (1, _37) (-1, _39) (-1, _40) -1 ]", + "BLACKBOX::RANGE [(_40, 64)] []", + "EXPR [ (-1, _37, _38) (-1, _39) 64 ]", + "EXPR [ (1, _38) -32 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0, _37) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_41, _42]", + "BLACKBOX::RANGE [(_41, 190)] []", + "EXPR [ (1, _0, _37) (-18446744073709551616, _41) (-1, _42) 0 ]", + "EXPR [ (-1, _41) (-1, _43) 1186564023676924939888766319973246049704924238154051448977 ]", + "BLACKBOX::RANGE [(_43, 190)] []", + "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _41) 1186564023676924939888766319973246049704924238154051448977 ]], outputs: [_44]", + "EXPR [ (-1, _41, _44) (1186564023676924939888766319973246049704924238154051448977, _44) (1, _45) -1 ]", + "EXPR [ (-1, _41, _45) (1186564023676924939888766319973246049704924238154051448977, _45) 0 ]", + "EXPR [ (1, _42, _45) (4331911350818177023, _45) (-1, _46) 0 ]", + "BLACKBOX::RANGE [(_46, 63)] []", + "EXPR [ (1, _42) -128 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _37) 0 ]], outputs: [_47]", + "EXPR [ (1, _37, _47) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _37) 0 ]], outputs: [_48, _49]", + "BLACKBOX::RANGE [(_49, 64)] []", + "EXPR [ (1, _37) (-1, _49) (-1, _50) -1 ]", + "BLACKBOX::RANGE [(_50, 64)] []", + "EXPR [ (-1, _37, _48) (1, _0) (-1, _49) 0 ]", + "EXPR [ (1, _48) -32 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 36893488147419103230 ], EXPR [ 18446744073709551616 ]], outputs: [_51, _52]", + "BLACKBOX::RANGE [(_51, 2)] []", + "BLACKBOX::RANGE [(_52, 64)] []", + "EXPR [ (1, _0) (-18446744073709551616, _51) (-1, _52) 36893488147419103230 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 9223372036854775808 ], EXPR [ 18446744073709551616 ]], outputs: [_53, _54]", + "BLACKBOX::RANGE [(_53, 1)] []", + "BLACKBOX::RANGE [(_54, 64)] []", + "EXPR [ (1, _0) (-18446744073709551616, _53) (-1, _54) 9223372036854775808 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _52) 9223372036854775808 ], EXPR [ 18446744073709551616 ]], outputs: [_55, _56]", + "BLACKBOX::RANGE [(_55, 1)] []", + "BLACKBOX::RANGE [(_56, 64)] []", + "EXPR [ (1, _52) (-18446744073709551616, _55) (-1, _56) 9223372036854775808 ]", + "EXPR [ (1, _53) (-1, _55) (-1, _57) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _57) 0 ]], outputs: [_58]", + "EXPR [ (1, _57, _58) (1, _59) -1 ]", + "EXPR [ (1, _57, _59) 0 ]", + "EXPR [ (1, _53, _59) (-1, _53) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _52) 18446744073709551553 ], EXPR [ 18446744073709551616 ]], outputs: [_60, _61]", + "BLACKBOX::RANGE [(_61, 64)] []", + "EXPR [ (1, _52) (-18446744073709551616, _60) (-1, _61) 18446744073709551553 ]", + "EXPR [ (-1, _60) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _52) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_62, _63]", + "BLACKBOX::RANGE [(_62, 1)] []", + "BLACKBOX::RANGE [(_63, 63)] []", + "EXPR [ (1, _52) (-9223372036854775808, _62) (-1, _63) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _52) 36893488147419103168 ], EXPR [ 36893488147419103232 ]], outputs: [_64, _65]", "BLACKBOX::RANGE [(_64, 1)] []", - "BLACKBOX::RANGE [(_65, 1)] []", - "BLACKBOX::RANGE [(_66, 1)] []", + "BLACKBOX::RANGE [(_65, 65)] []", + "EXPR [ (1, _52) (-36893488147419103232, _64) (-1, _65) 36893488147419103168 ]", + "EXPR [ (2, _62, _64) (-1, _62) (-1, _64) (-1, _66) 1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _66, _52) 0 ], EXPR [ 7 ], EXPR [ 2 ]], outputs: [[_67, _68, _69, _70, _71, _72, _73]]", "BLACKBOX::RANGE [(_67, 1)] []", "BLACKBOX::RANGE [(_68, 1)] []", "BLACKBOX::RANGE [(_69, 1)] []", "BLACKBOX::RANGE [(_70, 1)] []", - "EXPR [ (-1, _60, _61) (1, _60) (-1, _63) (-2, _64) (-4, _65) (-8, _66) (-16, _67) (-32, _68) (-64, _69) (-128, _70) 0 ]", - "EXPR [ (1, _70, _70) (2, _70) (-1, _71) 1 ]", - "EXPR [ (-1, _69) (-1, _72) 1 ]", - "EXPR [ (2, _69, _71) (1, _71, _72) (-1, _73) 0 ]", - "EXPR [ (1, _73, _73) (-1, _74) 0 ]", - "EXPR [ (-1, _68) (-1, _75) 1 ]", - "EXPR [ (2, _68, _74) (1, _74, _75) (-1, _76) 0 ]", + "BLACKBOX::RANGE [(_71, 1)] []", + "BLACKBOX::RANGE [(_72, 1)] []", + "BLACKBOX::RANGE [(_73, 1)] []", + "EXPR [ (1, _52, _66) (-1, _67) (-2, _68) (-4, _69) (-8, _70) (-16, _71) (-32, _72) (-64, _73) 0 ]", + "EXPR [ (1, _73, _73) (2, _73) (-1, _74) 1 ]", + "EXPR [ (-1, _72) (-1, _75) 1 ]", + "EXPR [ (2, _72, _74) (1, _74, _75) (-1, _76) 0 ]", "EXPR [ (1, _76, _76) (-1, _77) 0 ]", - "EXPR [ (-1, _67) (-1, _78) 1 ]", - "EXPR [ (2, _67, _77) (1, _77, _78) (-1, _79) 0 ]", + "EXPR [ (-1, _71) (-1, _78) 1 ]", + "EXPR [ (2, _71, _77) (1, _77, _78) (-1, _79) 0 ]", "EXPR [ (1, _79, _79) (-1, _80) 0 ]", - "EXPR [ (-1, _66) (-1, _81) 1 ]", - "EXPR [ (2, _66, _80) (1, _80, _81) (-1, _82) 0 ]", + "EXPR [ (-1, _70) (-1, _81) 1 ]", + "EXPR [ (2, _70, _80) (1, _80, _81) (-1, _82) 0 ]", "EXPR [ (1, _82, _82) (-1, _83) 0 ]", - "EXPR [ (-1, _65) (-1, _84) 1 ]", - "EXPR [ (2, _65, _83) (1, _83, _84) (-1, _85) 0 ]", + "EXPR [ (-1, _69) (-1, _84) 1 ]", + "EXPR [ (2, _69, _83) (1, _83, _84) (-1, _85) 0 ]", "EXPR [ (1, _85, _85) (-1, _86) 0 ]", - "EXPR [ (-1, _64) (-1, _87) 1 ]", - "EXPR [ (2, _64, _86) (1, _86, _87) (-1, _88) 0 ]", + "EXPR [ (-1, _68) (-1, _87) 1 ]", + "EXPR [ (2, _68, _86) (1, _86, _87) (-1, _88) 0 ]", "EXPR [ (1, _88, _88) (-1, _89) 0 ]", - "EXPR [ (-1, _63) (-1, _90) 1 ]", + "EXPR [ (-1, _67) (-1, _90) 1 ]", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _3) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_91, _92]", "BLACKBOX::RANGE [(_91, 1)] []", "BLACKBOX::RANGE [(_92, 63)] []", @@ -200,19 +217,19 @@ expression: artifact "BLACKBOX::RANGE [(_95, 1)] []", "BLACKBOX::RANGE [(_96, 64)] []", "EXPR [ (2, _91, _93) (1, _3) (-1, _91) (-1, _93) (-18446744073709551616, _95) (-1, _96) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _89, _63) (1, _89, _90) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_97, _98]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _89, _67) (1, _89, _90) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_97, _98]", "BLACKBOX::RANGE [(_97, 1)] []", "BLACKBOX::RANGE [(_98, 63)] []", - "EXPR [ (2, _63, _89) (-1, _364) 0 ]", - "EXPR [ (1, _89, _90) (-1, _365) 0 ]", - "EXPR [ (-9223372036854775808, _97) (-1, _98) (1, _364) (1, _365) 0 ]", + "EXPR [ (2, _67, _89) (-1, _428) 0 ]", + "EXPR [ (1, _89, _90) (-1, _429) 0 ]", + "EXPR [ (-9223372036854775808, _97) (-1, _98) (1, _428) (1, _429) 0 ]", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _96) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_99, _100]", "BLACKBOX::RANGE [(_99, 1)] []", "BLACKBOX::RANGE [(_100, 63)] []", "EXPR [ (1, _96) (-9223372036854775808, _99) (-1, _100) 0 ]", - "EXPR [ (-1, _101) (-1, _364) (-1, _365) 9223372036854775808 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _89, _63) (1, _89, _90) (2, _101, _97) 0 ]], outputs: [_102]", - "EXPR [ (2, _97, _101) (-1, _103) (1, _364) (1, _365) 0 ]", + "EXPR [ (-1, _101) (-1, _428) (-1, _429) 9223372036854775808 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _89, _67) (1, _89, _90) (2, _101, _97) 0 ]], outputs: [_102]", + "EXPR [ (2, _97, _101) (-1, _103) (1, _428) (1, _429) 0 ]", "EXPR [ (1, _102, _103) -1 ]", "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _96, _99) (1, _96) (18446744073709551616, _99) 0 ], EXPR [ (1, _103) 0 ]], outputs: [_104, _105]", "BLACKBOX::RANGE [(_104, 64)] []", @@ -237,336 +254,452 @@ expression: artifact "BLACKBOX::RANGE [(_118, 64)] []", "EXPR [ (-2, _91, _93) (1, _111, _112) (1, _91) (1, _93) (-18446744073709551616, _117) (-1, _118) 36893488147419103231 ]", "EXPR [ (36893488147419103230, _91, _93) (-18446744073709551615, _91) (-18446744073709551615, _93) (-1, _119) 18446744073709551615 ]", - "EXPR [ (-1, _61, _118) (1, _61, _119) (1, _118) -18446744073709551615 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _60) 240 ], EXPR [ 256 ]], outputs: [_120, _121]", - "BLACKBOX::RANGE [(_120, 1)] []", - "BLACKBOX::RANGE [(_121, 8)] []", - "EXPR [ (1, _60) (-256, _120) (-1, _121) 240 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _120, _60) (1, _60) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_122, _123, _124, _125, _126, _127, _128, _129]]", - "BLACKBOX::RANGE [(_122, 1)] []", - "BLACKBOX::RANGE [(_123, 1)] []", - "BLACKBOX::RANGE [(_124, 1)] []", - "BLACKBOX::RANGE [(_125, 1)] []", - "BLACKBOX::RANGE [(_126, 1)] []", + "EXPR [ (-1, _66) (-1, _120) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _66, _118) (1, _119, _120) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_121, _122]", + "BLACKBOX::RANGE [(_121, 1)] []", + "EXPR [ (1, _66, _118) (1, _119, _120) (-18446744073709551616, _121) (-1, _122) 0 ]", + "EXPR [ (1, _122) -18446744073709551615 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 0 ], EXPR [ 256 ]], outputs: [_123, _124]", + "BLACKBOX::RANGE [(_123, 56)] []", + "BLACKBOX::RANGE [(_124, 8)] []", + "EXPR [ (1, _1) (-256, _123) (-1, _124) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 256 ]], outputs: [_125, _126]", + "BLACKBOX::RANGE [(_125, 56)] []", + "BLACKBOX::RANGE [(_126, 8)] []", + "EXPR [ (1, _0) (-256, _125) (-1, _126) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _126) 0 ], EXPR [ 256 ]], outputs: [_127, _128]", "BLACKBOX::RANGE [(_127, 1)] []", - "BLACKBOX::RANGE [(_128, 1)] []", + "BLACKBOX::RANGE [(_128, 8)] []", + "EXPR [ (2, _126) (-256, _127) (-1, _128) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _128) 0 ], EXPR [ 256 ]], outputs: [_129, _130]", "BLACKBOX::RANGE [(_129, 1)] []", - "EXPR [ (-1, _60, _120) (1, _60) (-1, _122) (-2, _123) (-4, _124) (-8, _125) (-16, _126) (-32, _127) (-64, _128) (-128, _129) 0 ]", - "EXPR [ (1, _129, _129) (2, _129) (-1, _130) 1 ]", - "EXPR [ (-1, _128) (-1, _131) 1 ]", - "EXPR [ (2, _128, _130) (1, _130, _131) (-1, _132) 0 ]", - "EXPR [ (1, _132, _132) (-1, _133) 0 ]", - "EXPR [ (-1, _127) (-1, _134) 1 ]", - "EXPR [ (2, _127, _133) (1, _133, _134) (-1, _135) 0 ]", - "EXPR [ (1, _135, _135) (-1, _136) 0 ]", - "EXPR [ (-1, _126) (-1, _137) 1 ]", - "EXPR [ (2, _126, _136) (1, _136, _137) (-1, _138) 0 ]", - "EXPR [ (1, _138, _138) (-1, _139) 0 ]", - "EXPR [ (-1, _125) (-1, _140) 1 ]", - "EXPR [ (2, _125, _139) (1, _139, _140) (-1, _141) 0 ]", - "EXPR [ (1, _141, _141) (-1, _142) 0 ]", - "EXPR [ (-1, _124) (-1, _143) 1 ]", - "EXPR [ (2, _124, _142) (1, _142, _143) (-1, _144) 0 ]", - "EXPR [ (1, _144, _144) (-1, _145) 0 ]", - "EXPR [ (-1, _123) (-1, _146) 1 ]", - "EXPR [ (2, _123, _145) (1, _145, _146) (-1, _147) 0 ]", - "EXPR [ (1, _147, _147) (-1, _148) 0 ]", - "EXPR [ (-1, _122) (-1, _149) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 32768 ]], outputs: [_150, _151]", - "BLACKBOX::RANGE [(_150, 1)] []", - "BLACKBOX::RANGE [(_151, 15)] []", - "EXPR [ (1, _2) (-32768, _150) (-1, _151) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 131072 ], EXPR [ 131072 ]], outputs: [_152, _153]", - "BLACKBOX::RANGE [(_152, 1)] []", - "BLACKBOX::RANGE [(_153, 17)] []", - "EXPR [ (1, _2) (-131072, _152) (-1, _153) 131072 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _152, _150) (1, _2) (-1, _150) (-1, _152) 1 ], EXPR [ 65536 ]], outputs: [_154, _155]", - "BLACKBOX::RANGE [(_154, 1)] []", - "BLACKBOX::RANGE [(_155, 16)] []", - "EXPR [ (2, _150, _152) (1, _2) (-1, _150) (-1, _152) (-65536, _154) (-1, _155) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _148, _122) (1, _148, _149) 0 ], EXPR [ 32768 ]], outputs: [_156, _157]", - "BLACKBOX::RANGE [(_156, 1)] []", - "BLACKBOX::RANGE [(_157, 15)] []", - "EXPR [ (2, _122, _148) (-1, _389) 0 ]", - "EXPR [ (1, _148, _149) (-1, _390) 0 ]", - "EXPR [ (-32768, _156) (-1, _157) (1, _389) (1, _390) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _155) 0 ], EXPR [ 32768 ]], outputs: [_158, _159]", + "EXPR [ (1, _128) (-256, _129) (-1, _130) 0 ]", + "EXPR [ (1, _130) -128 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _126) 0 ], EXPR [ 128 ]], outputs: [_131, _132]", + "BLACKBOX::RANGE [(_131, 1)] []", + "BLACKBOX::RANGE [(_132, 7)] []", + "EXPR [ (1, _126) (-128, _131) (-1, _132) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _126) 512 ], EXPR [ 512 ]], outputs: [_133, _134]", + "BLACKBOX::RANGE [(_133, 1)] []", + "BLACKBOX::RANGE [(_134, 9)] []", + "EXPR [ (1, _126) (-512, _133) (-1, _134) 512 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _133, _131) (1, _126) (-1, _131) (-1, _133) 1 ], EXPR [ 256 ]], outputs: [_135, _136]", + "BLACKBOX::RANGE [(_135, 1)] []", + "BLACKBOX::RANGE [(_136, 8)] []", + "EXPR [ (2, _131, _133) (1, _126) (-1, _131) (-1, _133) (-256, _135) (-1, _136) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _136) 0 ], EXPR [ 128 ]], outputs: [_137, _138]", + "BLACKBOX::RANGE [(_137, 1)] []", + "BLACKBOX::RANGE [(_138, 7)] []", + "EXPR [ (1, _136) (-128, _137) (-1, _138) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _136, _137) (1, _136) (256, _137) 0 ], EXPR [ 4 ]], outputs: [_139, _140]", + "BLACKBOX::RANGE [(_139, 6)] []", + "BLACKBOX::RANGE [(_140, 2)] []", + "EXPR [ (-2, _136, _137) (1, _136) (256, _137) (-4, _139) (-1, _140) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _139) 0 ]], outputs: [_141]", + "EXPR [ (1, _139, _141) (1, _142) -1 ]", + "EXPR [ (1, _139, _142) 0 ]", + "EXPR [ (-2, _137, _139) (256, _137) (1, _139) (-1, _143) 0 ]", + "EXPR [ (-1, _142) (-1, _144) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _140) 0 ]], outputs: [_145]", + "EXPR [ (1, _140, _145) (1, _146) -1 ]", + "EXPR [ (1, _140, _146) 0 ]", + "EXPR [ (-2, _137, _140) (256, _137) (1, _140) (-1, _147) 0 ]", + "EXPR [ (-1, _146) (-1, _148) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _133, _131) (1, _143, _144) (1, _131) (1, _133) 511 ], EXPR [ 256 ]], outputs: [_149, _150]", + "BLACKBOX::RANGE [(_149, 2)] []", + "EXPR [ (-2, _131, _133) (1, _143, _144) (1, _131) (1, _133) (-256, _149) (-1, _150) 511 ]", + "EXPR [ (1, _150) -16 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _124) 249 ], EXPR [ 256 ]], outputs: [_151, _152]", + "BLACKBOX::RANGE [(_152, 8)] []", + "EXPR [ (1, _124) (-256, _151) (-1, _152) 249 ]", + "EXPR [ (-1, _151) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _124) 0 ], EXPR [ 128 ]], outputs: [_153, _154]", + "BLACKBOX::RANGE [(_153, 1)] []", + "BLACKBOX::RANGE [(_154, 7)] []", + "EXPR [ (1, _124) (-128, _153) (-1, _154) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _124) 504 ], EXPR [ 512 ]], outputs: [_155, _156]", + "BLACKBOX::RANGE [(_155, 1)] []", + "BLACKBOX::RANGE [(_156, 9)] []", + "EXPR [ (1, _124) (-512, _155) (-1, _156) 504 ]", + "EXPR [ (2, _153, _155) (-1, _153) (-1, _155) (-1, _157) 1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _157, _124) 0 ], EXPR [ 4 ], EXPR [ 2 ]], outputs: [[_158, _159, _160, _161]]", "BLACKBOX::RANGE [(_158, 1)] []", - "BLACKBOX::RANGE [(_159, 15)] []", - "EXPR [ (1, _155) (-32768, _158) (-1, _159) 0 ]", - "EXPR [ (-1, _160) (-1, _389) (-1, _390) 32768 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _148, _122) (1, _148, _149) (2, _160, _156) 0 ]], outputs: [_161]", - "EXPR [ (2, _156, _160) (-1, _162) (1, _389) (1, _390) 0 ]", - "EXPR [ (1, _161, _162) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _155, _158) (1, _155) (65536, _158) 0 ], EXPR [ (1, _162) 0 ]], outputs: [_163, _164]", - "BLACKBOX::RANGE [(_163, 16)] []", - "BLACKBOX::RANGE [(_164, 16)] []", - "EXPR [ (1, _162) (-1, _164) (-1, _165) -1 ]", - "BLACKBOX::RANGE [(_165, 16)] []", - "EXPR [ (-2, _155, _158) (-1, _162, _163) (1, _155) (65536, _158) (-1, _164) 0 ]", - "EXPR [ (-1, _163) (-1, _166) 32768 ]", - "EXPR [ (-2, _156, _158) (1, _156) (1, _158) (-1, _167) 0 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _163) 0 ]], outputs: [_168]", - "EXPR [ (1, _163, _168) (1, _169) -1 ]", - "EXPR [ (1, _163, _169) 0 ]", - "EXPR [ (2, _166, _167) (1, _163) (-1, _170) 0 ]", - "EXPR [ (-1, _169) (-1, _171) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _164) 0 ]], outputs: [_172]", - "EXPR [ (1, _164, _172) (1, _173) -1 ]", - "EXPR [ (1, _164, _173) 0 ]", - "EXPR [ (-2, _158, _164) (65536, _158) (1, _164) (-1, _174) 0 ]", - "EXPR [ (-1, _173) (-1, _175) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _152, _150) (1, _170, _171) (1, _150) (1, _152) 131071 ], EXPR [ 65536 ]], outputs: [_176, _177]", - "BLACKBOX::RANGE [(_176, 2)] []", - "BLACKBOX::RANGE [(_177, 16)] []", - "EXPR [ (-2, _150, _152) (1, _170, _171) (1, _150) (1, _152) (-65536, _176) (-1, _177) 131071 ]", - "EXPR [ (131070, _150, _152) (-65535, _150) (-65535, _152) (-1, _178) 65535 ]", - "EXPR [ (-1, _120, _177) (1, _120, _178) (1, _177) -65535 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _60) 0 ], EXPR [ 256 ]], outputs: [_179, _180]", - "BLACKBOX::RANGE [(_179, 1)] []", - "BLACKBOX::RANGE [(_180, 8)] []", - "EXPR [ (2, _60) (-256, _179) (-1, _180) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _180) 0 ], EXPR [ 256 ]], outputs: [_181, _182]", - "BLACKBOX::RANGE [(_181, 1)] []", - "EXPR [ (1, _180) (-256, _181) (-1, _182) 0 ]", - "EXPR [ (1, _182) -128 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _60) 0 ], EXPR [ 128 ]], outputs: [_183, _184]", - "BLACKBOX::RANGE [(_183, 1)] []", - "BLACKBOX::RANGE [(_184, 7)] []", - "EXPR [ (1, _60) (-128, _183) (-1, _184) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _60) 512 ], EXPR [ 512 ]], outputs: [_185, _186]", - "BLACKBOX::RANGE [(_185, 1)] []", - "BLACKBOX::RANGE [(_186, 9)] []", - "EXPR [ (1, _60) (-512, _185) (-1, _186) 512 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _185, _183) (1, _60) (-1, _183) (-1, _185) 1 ], EXPR [ 256 ]], outputs: [_187, _188]", - "BLACKBOX::RANGE [(_187, 1)] []", - "BLACKBOX::RANGE [(_188, 8)] []", - "EXPR [ (2, _183, _185) (1, _60) (-1, _183) (-1, _185) (-256, _187) (-1, _188) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _188) 0 ], EXPR [ 128 ]], outputs: [_189, _190]", - "BLACKBOX::RANGE [(_189, 1)] []", - "BLACKBOX::RANGE [(_190, 7)] []", - "EXPR [ (1, _188) (-128, _189) (-1, _190) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _188, _189) (1, _188) (256, _189) 0 ], EXPR [ 4 ]], outputs: [_191, _192]", - "BLACKBOX::RANGE [(_191, 6)] []", - "BLACKBOX::RANGE [(_192, 2)] []", - "EXPR [ (-2, _188, _189) (1, _188) (256, _189) (-4, _191) (-1, _192) 0 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _191) 0 ]], outputs: [_193]", - "EXPR [ (1, _191, _193) (1, _194) -1 ]", - "EXPR [ (1, _191, _194) 0 ]", - "EXPR [ (-2, _189, _191) (256, _189) (1, _191) (-1, _195) 0 ]", - "EXPR [ (-1, _194) (-1, _196) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _192) 0 ]], outputs: [_197]", - "EXPR [ (1, _192, _197) (1, _198) -1 ]", - "EXPR [ (1, _192, _198) 0 ]", - "EXPR [ (-2, _189, _192) (256, _189) (1, _192) (-1, _199) 0 ]", - "EXPR [ (-1, _198) (-1, _200) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _185, _183) (1, _195, _196) (1, _183) (1, _185) 511 ], EXPR [ 256 ]], outputs: [_201, _202]", - "BLACKBOX::RANGE [(_201, 2)] []", - "EXPR [ (-2, _183, _185) (1, _195, _196) (1, _183) (1, _185) (-256, _201) (-1, _202) 511 ]", - "EXPR [ (1, _202) -16 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 248 ], EXPR [ 256 ]], outputs: [_203, _204]", - "BLACKBOX::RANGE [(_204, 8)] []", - "EXPR [ (1, _1) (-256, _203) (-1, _204) 248 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _203, _1) (1, _1) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_205, _206, _207, _208, _209, _210, _211, _212]]", - "BLACKBOX::RANGE [(_205, 1)] []", - "BLACKBOX::RANGE [(_206, 1)] []", - "BLACKBOX::RANGE [(_207, 1)] []", + "BLACKBOX::RANGE [(_159, 1)] []", + "BLACKBOX::RANGE [(_160, 1)] []", + "BLACKBOX::RANGE [(_161, 1)] []", + "EXPR [ (1, _124, _157) (-1, _158) (-2, _159) (-4, _160) (-8, _161) 0 ]", + "EXPR [ (1, _161, _161) (2, _161) (-1, _162) 1 ]", + "EXPR [ (-1, _160) (-1, _163) 1 ]", + "EXPR [ (2, _160, _162) (1, _162, _163) (-1, _164) 0 ]", + "EXPR [ (1, _164, _164) (-1, _165) 0 ]", + "EXPR [ (-1, _159) (-1, _166) 1 ]", + "EXPR [ (2, _159, _165) (1, _165, _166) (-1, _167) 0 ]", + "EXPR [ (1, _167, _167) (-1, _168) 0 ]", + "EXPR [ (-1, _158) (-1, _169) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _168, _158) (1, _168, _169) 0 ], EXPR [ 128 ]], outputs: [_170, _171]", + "BLACKBOX::RANGE [(_170, 1)] []", + "BLACKBOX::RANGE [(_171, 7)] []", + "EXPR [ (2, _158, _168) (-1, _444) 0 ]", + "EXPR [ (1, _168, _169) (-1, _445) 0 ]", + "EXPR [ (-128, _170) (-1, _171) (1, _444) (1, _445) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _136) 0 ], EXPR [ 128 ]], outputs: [_172, _173]", + "BLACKBOX::RANGE [(_172, 1)] []", + "BLACKBOX::RANGE [(_173, 7)] []", + "EXPR [ (1, _136) (-128, _172) (-1, _173) 0 ]", + "EXPR [ (-1, _174) (-1, _444) (-1, _445) 128 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _168, _158) (1, _168, _169) (2, _174, _170) 0 ]], outputs: [_175]", + "EXPR [ (2, _170, _174) (-1, _176) (1, _444) (1, _445) 0 ]", + "EXPR [ (1, _175, _176) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _136, _172) (1, _136) (256, _172) 0 ], EXPR [ (1, _176) 0 ]], outputs: [_177, _178]", + "BLACKBOX::RANGE [(_177, 8)] []", + "BLACKBOX::RANGE [(_178, 8)] []", + "EXPR [ (1, _176) (-1, _178) (-1, _179) -1 ]", + "BLACKBOX::RANGE [(_179, 8)] []", + "EXPR [ (-2, _136, _172) (-1, _176, _177) (1, _136) (256, _172) (-1, _178) 0 ]", + "EXPR [ (-1, _177) (-1, _180) 128 ]", + "EXPR [ (-2, _170, _172) (1, _170) (1, _172) (-1, _181) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _177) 0 ]], outputs: [_182]", + "EXPR [ (1, _177, _182) (1, _183) -1 ]", + "EXPR [ (1, _177, _183) 0 ]", + "EXPR [ (2, _180, _181) (1, _177) (-1, _184) 0 ]", + "EXPR [ (-1, _183) (-1, _185) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _178) 0 ]], outputs: [_186]", + "EXPR [ (1, _178, _186) (1, _187) -1 ]", + "EXPR [ (1, _178, _187) 0 ]", + "EXPR [ (-2, _172, _178) (256, _172) (1, _178) (-1, _188) 0 ]", + "EXPR [ (-1, _187) (-1, _189) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _133, _131) (1, _184, _185) (1, _131) (1, _133) 511 ], EXPR [ 256 ]], outputs: [_190, _191]", + "BLACKBOX::RANGE [(_190, 2)] []", + "BLACKBOX::RANGE [(_191, 8)] []", + "EXPR [ (-2, _131, _133) (1, _184, _185) (1, _131) (1, _133) (-256, _190) (-1, _191) 511 ]", + "EXPR [ (510, _131, _133) (-255, _131) (-255, _133) (-1, _192) 255 ]", + "EXPR [ (-1, _157) (-1, _193) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _157, _191) (1, _192, _193) 0 ], EXPR [ 256 ]], outputs: [_194, _195]", + "BLACKBOX::RANGE [(_194, 1)] []", + "EXPR [ (1, _157, _191) (1, _192, _193) (-256, _194) (-1, _195) 0 ]", + "EXPR [ (1, _195) -32 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _124) 512 ], EXPR [ 256 ]], outputs: [_196, _197]", + "BLACKBOX::RANGE [(_196, 2)] []", + "BLACKBOX::RANGE [(_197, 8)] []", + "EXPR [ (-1, _124) (-256, _196) (-1, _197) 512 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _124) 128 ], EXPR [ 256 ]], outputs: [_198, _199]", + "BLACKBOX::RANGE [(_198, 1)] []", + "BLACKBOX::RANGE [(_199, 8)] []", + "EXPR [ (1, _124) (-256, _198) (-1, _199) 128 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _197) 128 ], EXPR [ 256 ]], outputs: [_200, _201]", + "BLACKBOX::RANGE [(_200, 1)] []", + "BLACKBOX::RANGE [(_201, 8)] []", + "EXPR [ (1, _197) (-256, _200) (-1, _201) 128 ]", + "EXPR [ (-1, _198, _200) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (64, _197) 0 ], EXPR [ 256 ]], outputs: [_202, _203]", + "BLACKBOX::RANGE [(_202, 6)] []", + "BLACKBOX::RANGE [(_203, 8)] []", + "EXPR [ (64, _197) (-256, _202) (-1, _203) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _203) 0 ], EXPR [ 256 ]], outputs: [_204, _205]", + "BLACKBOX::RANGE [(_204, 1)] []", + "EXPR [ (1, _203) (-256, _204) (-1, _205) 0 ]", + "EXPR [ (1, _205) -192 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _197) 512 ], EXPR [ 256 ]], outputs: [_206, _207]", + "BLACKBOX::RANGE [(_206, 2)] []", + "BLACKBOX::RANGE [(_207, 8)] []", + "EXPR [ (-1, _197) (-256, _206) (-1, _207) 512 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _207) 128 ], EXPR [ 256 ]], outputs: [_208, _209]", "BLACKBOX::RANGE [(_208, 1)] []", - "BLACKBOX::RANGE [(_209, 1)] []", - "BLACKBOX::RANGE [(_210, 1)] []", - "BLACKBOX::RANGE [(_211, 1)] []", + "BLACKBOX::RANGE [(_209, 8)] []", + "EXPR [ (1, _207) (-256, _208) (-1, _209) 128 ]", + "EXPR [ (-1, _200, _208) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _207) 249 ], EXPR [ 256 ]], outputs: [_210, _211]", + "BLACKBOX::RANGE [(_211, 8)] []", + "EXPR [ (1, _207) (-256, _210) (-1, _211) 249 ]", + "EXPR [ (-1, _210) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _207) 0 ], EXPR [ 128 ]], outputs: [_212, _213]", "BLACKBOX::RANGE [(_212, 1)] []", - "EXPR [ (-1, _1, _203) (1, _1) (-1, _205) (-2, _206) (-4, _207) (-8, _208) (-16, _209) (-32, _210) (-64, _211) (-128, _212) 0 ]", - "EXPR [ (1, _212, _212) (2, _212) (-1, _213) 1 ]", - "EXPR [ (-1, _211) (-1, _214) 1 ]", - "EXPR [ (2, _211, _213) (1, _213, _214) (-1, _215) 0 ]", - "EXPR [ (1, _215, _215) (-1, _216) 0 ]", - "EXPR [ (-1, _210) (-1, _217) 1 ]", - "EXPR [ (2, _210, _216) (1, _216, _217) (-1, _218) 0 ]", - "EXPR [ (1, _218, _218) (-1, _219) 0 ]", - "EXPR [ (-1, _209) (-1, _220) 1 ]", - "EXPR [ (2, _209, _219) (1, _219, _220) (-1, _221) 0 ]", - "EXPR [ (1, _221, _221) (-1, _222) 0 ]", - "EXPR [ (-1, _208) (-1, _223) 1 ]", - "EXPR [ (2, _208, _222) (1, _222, _223) (-1, _224) 0 ]", - "EXPR [ (1, _224, _224) (-1, _225) 0 ]", - "EXPR [ (-1, _207) (-1, _226) 1 ]", - "EXPR [ (2, _207, _225) (1, _225, _226) (-1, _227) 0 ]", - "EXPR [ (1, _227, _227) (-1, _228) 0 ]", - "EXPR [ (-1, _206) (-1, _229) 1 ]", - "EXPR [ (2, _206, _228) (1, _228, _229) (-1, _230) 0 ]", - "EXPR [ (1, _230, _230) (-1, _231) 0 ]", - "EXPR [ (-1, _205) (-1, _232) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _231, _205) (1, _231, _232) 0 ], EXPR [ 128 ]], outputs: [_233, _234]", - "BLACKBOX::RANGE [(_233, 1)] []", - "BLACKBOX::RANGE [(_234, 7)] []", - "EXPR [ (2, _205, _231) (-1, _415) 0 ]", - "EXPR [ (1, _231, _232) (-1, _416) 0 ]", - "EXPR [ (-128, _233) (-1, _234) (1, _415) (1, _416) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _188) 0 ], EXPR [ 128 ]], outputs: [_235, _236]", - "BLACKBOX::RANGE [(_235, 1)] []", - "BLACKBOX::RANGE [(_236, 7)] []", - "EXPR [ (1, _188) (-128, _235) (-1, _236) 0 ]", - "EXPR [ (-1, _237) (-1, _415) (-1, _416) 128 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _231, _205) (1, _231, _232) (2, _237, _233) 0 ]], outputs: [_238]", - "EXPR [ (2, _233, _237) (-1, _239) (1, _415) (1, _416) 0 ]", - "EXPR [ (1, _238, _239) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _188, _235) (1, _188) (256, _235) 0 ], EXPR [ (1, _239) 0 ]], outputs: [_240, _241]", - "BLACKBOX::RANGE [(_240, 8)] []", - "BLACKBOX::RANGE [(_241, 8)] []", - "EXPR [ (1, _239) (-1, _241) (-1, _242) -1 ]", - "BLACKBOX::RANGE [(_242, 8)] []", - "EXPR [ (-2, _188, _235) (-1, _239, _240) (1, _188) (256, _235) (-1, _241) 0 ]", - "EXPR [ (-1, _240) (-1, _243) 128 ]", - "EXPR [ (-2, _233, _235) (1, _233) (1, _235) (-1, _244) 0 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _240) 0 ]], outputs: [_245]", - "EXPR [ (1, _240, _245) (1, _246) -1 ]", - "EXPR [ (1, _240, _246) 0 ]", - "EXPR [ (2, _243, _244) (1, _240) (-1, _247) 0 ]", - "EXPR [ (-1, _246) (-1, _248) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _241) 0 ]], outputs: [_249]", - "EXPR [ (1, _241, _249) (1, _250) -1 ]", - "EXPR [ (1, _241, _250) 0 ]", - "EXPR [ (-2, _235, _241) (256, _235) (1, _241) (-1, _251) 0 ]", - "EXPR [ (-1, _250) (-1, _252) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _185, _183) (1, _247, _248) (1, _183) (1, _185) 511 ], EXPR [ 256 ]], outputs: [_253, _254]", - "BLACKBOX::RANGE [(_253, 2)] []", - "BLACKBOX::RANGE [(_254, 8)] []", - "EXPR [ (-2, _183, _185) (1, _247, _248) (1, _183) (1, _185) (-256, _253) (-1, _254) 511 ]", - "EXPR [ (510, _183, _185) (-255, _183) (-255, _185) (-1, _255) 255 ]", - "EXPR [ (-1, _203, _254) (1, _203, _255) (1, _254) -32 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _1) 512 ], EXPR [ 256 ]], outputs: [_256, _257]", - "BLACKBOX::RANGE [(_256, 2)] []", - "BLACKBOX::RANGE [(_257, 8)] []", - "EXPR [ (-1, _1) (-256, _256) (-1, _257) 512 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 128 ], EXPR [ 256 ]], outputs: [_258, _259]", - "BLACKBOX::RANGE [(_258, 1)] []", - "BLACKBOX::RANGE [(_259, 8)] []", - "EXPR [ (1, _1) (-256, _258) (-1, _259) 128 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _257) 128 ], EXPR [ 256 ]], outputs: [_260, _261]", - "BLACKBOX::RANGE [(_260, 1)] []", - "BLACKBOX::RANGE [(_261, 8)] []", - "EXPR [ (1, _257) (-256, _260) (-1, _261) 128 ]", - "EXPR [ (-1, _258, _260) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (128, _257) 0 ], EXPR [ 256 ]], outputs: [_262, _263]", - "BLACKBOX::RANGE [(_262, 7)] []", - "BLACKBOX::RANGE [(_263, 8)] []", - "EXPR [ (128, _257) (-256, _262) (-1, _263) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _263) 0 ], EXPR [ 256 ]], outputs: [_264, _265]", - "BLACKBOX::RANGE [(_264, 1)] []", - "EXPR [ (1, _263) (-256, _264) (-1, _265) 0 ]", - "EXPR [ (1, _265) -128 ]", - "EXPR [ (-1, _35, _203) (1, _35) (-1, _266) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _257, _266) 0 ], EXPR [ 256 ]], outputs: [_267, _268]", - "BLACKBOX::RANGE [(_267, 246)] []", - "BLACKBOX::RANGE [(_268, 8)] []", - "EXPR [ (1, _257, _266) (-256, _267) (-1, _268) 0 ]", - "EXPR [ (-1, _267) (-1, _269) 85500948718122168836900022442411230814642048439125134155071110103811751936 ]", - "BLACKBOX::RANGE [(_269, 246)] []", - "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _267) 85500948718122168836900022442411230814642048439125134155071110103811751936 ]], outputs: [_270]", - "EXPR [ (-1, _267, _270) (85500948718122168836900022442411230814642048439125134155071110103811751936, _270) (1, _271) -1 ]", - "EXPR [ (-1, _267, _271) (85500948718122168836900022442411230814642048439125134155071110103811751936, _271) 0 ]", - "EXPR [ (1, _268, _271) (-1, _272) 0 ]", - "BLACKBOX::RANGE [(_272, 0)] []", - "EXPR [ (-1, _203) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _268) 0 ], EXPR [ 256 ]], outputs: [_273, _274]", + "BLACKBOX::RANGE [(_213, 7)] []", + "EXPR [ (1, _207) (-128, _212) (-1, _213) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _207) 504 ], EXPR [ 512 ]], outputs: [_214, _215]", + "BLACKBOX::RANGE [(_214, 1)] []", + "BLACKBOX::RANGE [(_215, 9)] []", + "EXPR [ (1, _207) (-512, _214) (-1, _215) 504 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _207) 0 ], EXPR [ 4 ], EXPR [ 2 ]], outputs: [[_216, _217, _218, _219]]", + "BLACKBOX::RANGE [(_216, 1)] []", + "BLACKBOX::RANGE [(_217, 1)] []", + "BLACKBOX::RANGE [(_218, 1)] []", + "BLACKBOX::RANGE [(_219, 1)] []", + "EXPR [ (1, _207) (-1, _216) (-2, _217) (-4, _218) (-8, _219) 0 ]", + "EXPR [ (1, _219, _219) (2, _219) (-1, _220) 1 ]", + "EXPR [ (-1, _218) (-1, _221) 1 ]", + "EXPR [ (2, _218, _220) (1, _220, _221) (-1, _222) 0 ]", + "EXPR [ (1, _222, _222) (-1, _223) 0 ]", + "EXPR [ (-1, _217) (-1, _224) 1 ]", + "EXPR [ (2, _217, _223) (1, _223, _224) (-1, _225) 0 ]", + "EXPR [ (1, _225, _225) (-1, _226) 0 ]", + "EXPR [ (-1, _216) (-1, _227) 1 ]", + "EXPR [ (2, _212, _214) (-1, _212) (-1, _214) (-1, _228) 1 ]", + "EXPR [ (2, _216, _226) (1, _226, _227) (-1, _229) 0 ]", + "EXPR [ (1, _228, _229) (-1, _230) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _197, _230) 0 ], EXPR [ 256 ]], outputs: [_231, _232]", + "BLACKBOX::RANGE [(_231, 246)] []", + "BLACKBOX::RANGE [(_232, 8)] []", + "EXPR [ (1, _197, _230) (-256, _231) (-1, _232) 0 ]", + "EXPR [ (-1, _231) (-1, _233) 85500948718122168836900022442411230814642048439125134155071110103811751936 ]", + "BLACKBOX::RANGE [(_233, 246)] []", + "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _231) 85500948718122168836900022442411230814642048439125134155071110103811751936 ]], outputs: [_234]", + "EXPR [ (-1, _231, _234) (85500948718122168836900022442411230814642048439125134155071110103811751936, _234) (1, _235) -1 ]", + "EXPR [ (-1, _231, _235) (85500948718122168836900022442411230814642048439125134155071110103811751936, _235) 0 ]", + "EXPR [ (1, _232, _235) (-1, _236) 0 ]", + "BLACKBOX::RANGE [(_236, 0)] []", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _232) 0 ], EXPR [ 256 ]], outputs: [_237, _238]", + "BLACKBOX::RANGE [(_237, 1)] []", + "EXPR [ (1, _232) (-256, _237) (-1, _238) 0 ]", + "EXPR [ (1, _238) -254 ]", + "EXPR [ (1, _0) (-1, _239) -1 ]", + "BLACKBOX::RANGE [(_239, 64)] []", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _239) 18446744073709551552 ], EXPR [ 18446744073709551616 ]], outputs: [_240, _241]", + "BLACKBOX::RANGE [(_241, 64)] []", + "EXPR [ (1, _239) (-18446744073709551616, _240) (-1, _241) 18446744073709551552 ]", + "EXPR [ (-1, _240) 0 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _239) 0 ], EXPR [ 7 ], EXPR [ 2 ]], outputs: [[_242, _243, _244, _245, _246, _247, _248]]", + "BLACKBOX::RANGE [(_242, 1)] []", + "BLACKBOX::RANGE [(_243, 1)] []", + "BLACKBOX::RANGE [(_244, 1)] []", + "BLACKBOX::RANGE [(_245, 1)] []", + "BLACKBOX::RANGE [(_246, 1)] []", + "BLACKBOX::RANGE [(_247, 1)] []", + "BLACKBOX::RANGE [(_248, 1)] []", + "EXPR [ (1, _239) (-1, _242) (-2, _243) (-4, _244) (-8, _245) (-16, _246) (-32, _247) (-64, _248) 0 ]", + "EXPR [ (1, _248, _248) (2, _248) (-1, _249) 1 ]", + "EXPR [ (-1, _247) (-1, _250) 1 ]", + "EXPR [ (2, _247, _249) (1, _249, _250) (-1, _251) 0 ]", + "EXPR [ (1, _251, _251) (-1, _252) 0 ]", + "EXPR [ (-1, _246) (-1, _253) 1 ]", + "EXPR [ (2, _246, _252) (1, _252, _253) (-1, _254) 0 ]", + "EXPR [ (1, _254, _254) (-1, _255) 0 ]", + "EXPR [ (-1, _245) (-1, _256) 1 ]", + "EXPR [ (2, _245, _255) (1, _255, _256) (-1, _257) 0 ]", + "EXPR [ (1, _257, _257) (-1, _258) 0 ]", + "EXPR [ (-1, _244) (-1, _259) 1 ]", + "EXPR [ (2, _244, _258) (1, _258, _259) (-1, _260) 0 ]", + "EXPR [ (1, _260, _260) (-1, _261) 0 ]", + "EXPR [ (-1, _243) (-1, _262) 1 ]", + "EXPR [ (2, _243, _261) (1, _261, _262) (-1, _263) 0 ]", + "EXPR [ (1, _263, _263) (-1, _264) 0 ]", + "EXPR [ (-1, _242) (-1, _265) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _264, _242) (1, _264, _265) 0 ]], outputs: [_266]", + "EXPR [ (2, _242, _264) (1, _264, _265) (-1, _267) 0 ]", + "EXPR [ (1, _266, _267) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _267) 0 ]], outputs: [_268, _269]", + "BLACKBOX::RANGE [(_269, 64)] []", + "EXPR [ (1, _267) (-1, _269) (-1, _270) -1 ]", + "BLACKBOX::RANGE [(_270, 64)] []", + "EXPR [ (-1, _267, _268) (1, _0) (-1, _269) 0 ]", + "EXPR [ (1, _268) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 32768 ]], outputs: [_271, _272]", + "BLACKBOX::RANGE [(_271, 1)] []", + "BLACKBOX::RANGE [(_272, 15)] []", + "EXPR [ (1, _2) (-32768, _271) (-1, _272) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 131072 ], EXPR [ 131072 ]], outputs: [_273, _274]", "BLACKBOX::RANGE [(_273, 1)] []", - "EXPR [ (1, _268) (-256, _273) (-1, _274) 0 ]", - "EXPR [ (1, _274) -254 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _89, _63) (1, _89, _90) 0 ]], outputs: [_275]", - "EXPR [ (-1, _276) (1, _364) (1, _365) 0 ]", - "EXPR [ (1, _275, _276) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _276) 0 ]], outputs: [_277, _278]", - "BLACKBOX::RANGE [(_277, 64)] []", - "BLACKBOX::RANGE [(_278, 64)] []", - "EXPR [ (1, _276) (-1, _278) (-1, _279) -1 ]", - "BLACKBOX::RANGE [(_279, 64)] []", - "EXPR [ (-1, _276, _277) (1, _0) (-1, _278) 0 ]", - "EXPR [ (-1, _61, _277) (1, _277) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _155) 0 ], EXPR [ 32768 ]], outputs: [_280, _281]", - "BLACKBOX::RANGE [(_280, 1)] []", - "BLACKBOX::RANGE [(_281, 15)] []", - "EXPR [ (1, _155) (-32768, _280) (-1, _281) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _155, _280) (1, _155) (65536, _280) 0 ], EXPR [ 8 ]], outputs: [_282, _283]", - "BLACKBOX::RANGE [(_282, 13)] []", - "BLACKBOX::RANGE [(_283, 3)] []", - "EXPR [ (-2, _155, _280) (1, _155) (65536, _280) (-8, _282) (-1, _283) 0 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _282) 0 ]], outputs: [_284]", - "EXPR [ (1, _282, _284) (1, _285) -1 ]", - "EXPR [ (1, _282, _285) 0 ]", - "EXPR [ (-2, _280, _282) (65536, _280) (1, _282) (-1, _286) 0 ]", - "EXPR [ (-1, _285) (-1, _287) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _283) 0 ]], outputs: [_288]", - "EXPR [ (1, _283, _288) (1, _289) -1 ]", - "EXPR [ (1, _283, _289) 0 ]", - "EXPR [ (-2, _280, _283) (65536, _280) (1, _283) (-1, _290) 0 ]", - "EXPR [ (-1, _289) (-1, _291) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _152, _150) (1, _286, _287) (1, _150) (1, _152) 131071 ], EXPR [ 65536 ]], outputs: [_292, _293]", - "BLACKBOX::RANGE [(_292, 2)] []", - "EXPR [ (-2, _150, _152) (1, _286, _287) (1, _150) (1, _152) (-65536, _292) (-1, _293) 131071 ]", - "EXPR [ (1, _293) -65439 ]", - "EXPR [ (1, _178) -65535 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _2) 131072 ], EXPR [ 65536 ]], outputs: [_294, _295]", - "BLACKBOX::RANGE [(_294, 2)] []", - "BLACKBOX::RANGE [(_295, 16)] []", - "EXPR [ (-1, _2) (-65536, _294) (-1, _295) 131072 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 32768 ], EXPR [ 65536 ]], outputs: [_296, _297]", - "BLACKBOX::RANGE [(_296, 1)] []", - "BLACKBOX::RANGE [(_297, 16)] []", - "EXPR [ (1, _2) (-65536, _296) (-1, _297) 32768 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _295) 32768 ], EXPR [ 65536 ]], outputs: [_298, _299]", - "BLACKBOX::RANGE [(_298, 1)] []", - "BLACKBOX::RANGE [(_299, 16)] []", - "EXPR [ (1, _295) (-65536, _298) (-1, _299) 32768 ]", - "EXPR [ (-1, _296, _298) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _295) 0 ], EXPR [ 32768 ]], outputs: [_300, _301]", - "BLACKBOX::RANGE [(_300, 1)] []", - "BLACKBOX::RANGE [(_301, 15)] []", - "EXPR [ (1, _295) (-32768, _300) (-1, _301) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _295) 131072 ], EXPR [ 131072 ]], outputs: [_302, _303]", - "BLACKBOX::RANGE [(_302, 1)] []", - "BLACKBOX::RANGE [(_303, 17)] []", - "EXPR [ (1, _295) (-131072, _302) (-1, _303) 131072 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _302, _300) (1, _295) (-1, _300) (-1, _302) 1 ], EXPR [ 65536 ]], outputs: [_304, _305]", - "BLACKBOX::RANGE [(_304, 1)] []", - "BLACKBOX::RANGE [(_305, 16)] []", - "EXPR [ (2, _300, _302) (1, _295) (-1, _300) (-1, _302) (-65536, _304) (-1, _305) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _148, _122) (1, _148, _149) 0 ], EXPR [ 32768 ]], outputs: [_306, _307]", - "BLACKBOX::RANGE [(_306, 1)] []", - "BLACKBOX::RANGE [(_307, 15)] []", - "EXPR [ (-32768, _306) (-1, _307) (1, _389) (1, _390) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _305) 0 ], EXPR [ 32768 ]], outputs: [_308, _309]", - "BLACKBOX::RANGE [(_308, 1)] []", - "BLACKBOX::RANGE [(_309, 15)] []", - "EXPR [ (1, _305) (-32768, _308) (-1, _309) 0 ]", - "EXPR [ (-1, _310) (-1, _389) (-1, _390) 32768 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _148, _122) (1, _148, _149) (2, _310, _306) 0 ]], outputs: [_311]", - "EXPR [ (2, _306, _310) (-1, _312) (1, _389) (1, _390) 0 ]", - "EXPR [ (1, _311, _312) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _305, _308) (1, _305) (65536, _308) 0 ], EXPR [ (1, _312) 0 ]], outputs: [_313, _314]", + "BLACKBOX::RANGE [(_274, 17)] []", + "EXPR [ (1, _2) (-131072, _273) (-1, _274) 131072 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _273, _271) (1, _2) (-1, _271) (-1, _273) 1 ], EXPR [ 65536 ]], outputs: [_275, _276]", + "BLACKBOX::RANGE [(_275, 1)] []", + "BLACKBOX::RANGE [(_276, 16)] []", + "EXPR [ (2, _271, _273) (1, _2) (-1, _271) (-1, _273) (-65536, _275) (-1, _276) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _276) 0 ], EXPR [ 32768 ]], outputs: [_277, _278]", + "BLACKBOX::RANGE [(_277, 1)] []", + "BLACKBOX::RANGE [(_278, 15)] []", + "EXPR [ (1, _276) (-32768, _277) (-1, _278) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _276, _277) (1, _276) (65536, _277) 0 ], EXPR [ 8 ]], outputs: [_279, _280]", + "BLACKBOX::RANGE [(_279, 13)] []", + "BLACKBOX::RANGE [(_280, 3)] []", + "EXPR [ (-2, _276, _277) (1, _276) (65536, _277) (-8, _279) (-1, _280) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _279) 0 ]], outputs: [_281]", + "EXPR [ (1, _279, _281) (1, _282) -1 ]", + "EXPR [ (1, _279, _282) 0 ]", + "EXPR [ (-2, _277, _279) (65536, _277) (1, _279) (-1, _283) 0 ]", + "EXPR [ (-1, _282) (-1, _284) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _280) 0 ]], outputs: [_285]", + "EXPR [ (1, _280, _285) (1, _286) -1 ]", + "EXPR [ (1, _280, _286) 0 ]", + "EXPR [ (-2, _277, _280) (65536, _277) (1, _280) (-1, _287) 0 ]", + "EXPR [ (-1, _286) (-1, _288) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _273, _271) (1, _283, _284) (1, _271) (1, _273) 131071 ], EXPR [ 65536 ]], outputs: [_289, _290]", + "BLACKBOX::RANGE [(_289, 2)] []", + "EXPR [ (-2, _271, _273) (1, _283, _284) (1, _271) (1, _273) (-65536, _289) (-1, _290) 131071 ]", + "EXPR [ (1, _290) -65439 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _276) 0 ], EXPR [ 32768 ]], outputs: [_291, _292]", + "BLACKBOX::RANGE [(_291, 1)] []", + "BLACKBOX::RANGE [(_292, 15)] []", + "EXPR [ (1, _276) (-32768, _291) (-1, _292) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _276, _291) (1, _276) (65536, _291) 0 ], EXPR [ 16384 ]], outputs: [_293, _294]", + "BLACKBOX::RANGE [(_293, 2)] []", + "BLACKBOX::RANGE [(_294, 14)] []", + "EXPR [ (-2, _276, _291) (1, _276) (65536, _291) (-16384, _293) (-1, _294) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _293) 0 ]], outputs: [_295]", + "EXPR [ (1, _293, _295) (1, _296) -1 ]", + "EXPR [ (1, _293, _296) 0 ]", + "EXPR [ (-2, _291, _293) (65536, _291) (1, _293) (-1, _297) 0 ]", + "EXPR [ (-1, _296) (-1, _298) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _294) 0 ]], outputs: [_299]", + "EXPR [ (1, _294, _299) (1, _300) -1 ]", + "EXPR [ (1, _294, _300) 0 ]", + "EXPR [ (-2, _291, _294) (65536, _291) (1, _294) (-1, _301) 0 ]", + "EXPR [ (-1, _300) (-1, _302) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _273, _271) (1, _297, _298) (1, _271) (1, _273) 131071 ], EXPR [ 65536 ]], outputs: [_303, _304]", + "BLACKBOX::RANGE [(_303, 2)] []", + "EXPR [ (-2, _271, _273) (1, _297, _298) (1, _271) (1, _273) (-65536, _303) (-1, _304) 131071 ]", + "EXPR [ (1, _304) -65535 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 65536 ]], outputs: [_305, _306]", + "BLACKBOX::RANGE [(_305, 48)] []", + "BLACKBOX::RANGE [(_306, 16)] []", + "EXPR [ (1, _0) (-65536, _305) (-1, _306) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _306) 0 ], EXPR [ 32768 ]], outputs: [_307, _308]", + "BLACKBOX::RANGE [(_307, 1)] []", + "BLACKBOX::RANGE [(_308, 15)] []", + "EXPR [ (1, _306) (-32768, _307) (-1, _308) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _306) 131086 ], EXPR [ 131072 ]], outputs: [_309, _310]", + "BLACKBOX::RANGE [(_309, 1)] []", + "BLACKBOX::RANGE [(_310, 17)] []", + "EXPR [ (-1, _306) (-131072, _309) (-1, _310) 131086 ]", + "EXPR [ (-2, _307, _309) (1, _307) (1, _309) (-1, _311) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (28, _309, _307) (1, _311, _306) (-14, _307) (-14, _309) 65535 ], EXPR [ 65536 ]], outputs: [_312, _313]", "BLACKBOX::RANGE [(_313, 16)] []", - "BLACKBOX::RANGE [(_314, 16)] []", - "EXPR [ (1, _312) (-1, _314) (-1, _315) -1 ]", - "BLACKBOX::RANGE [(_315, 16)] []", - "EXPR [ (-2, _305, _308) (-1, _312, _313) (1, _305) (65536, _308) (-1, _314) 0 ]", - "EXPR [ (-1, _313) (-1, _316) 32768 ]", - "EXPR [ (-2, _306, _308) (1, _306) (1, _308) (-1, _317) 0 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _313) 0 ]], outputs: [_318]", - "EXPR [ (1, _313, _318) (1, _319) -1 ]", - "EXPR [ (1, _313, _319) 0 ]", - "EXPR [ (2, _316, _317) (1, _313) (-1, _320) 0 ]", - "EXPR [ (-1, _319) (-1, _321) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _314) 0 ]], outputs: [_322]", - "EXPR [ (1, _314, _322) (1, _323) -1 ]", - "EXPR [ (1, _314, _323) 0 ]", - "EXPR [ (-2, _308, _314) (65536, _308) (1, _314) (-1, _324) 0 ]", - "EXPR [ (-1, _323) (-1, _325) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _302, _300) (1, _320, _321) (1, _300) (1, _302) 131071 ], EXPR [ 65536 ]], outputs: [_326, _327]", - "BLACKBOX::RANGE [(_326, 2)] []", - "BLACKBOX::RANGE [(_327, 16)] []", - "EXPR [ (-2, _300, _302) (1, _320, _321) (1, _300) (1, _302) (-65536, _326) (-1, _327) 131071 ]", - "EXPR [ (131070, _300, _302) (-65535, _300) (-65535, _302) (-1, _328) 65535 ]", - "EXPR [ (-1, _120, _327) (1, _120, _328) (1, _327) 0 ]", + "EXPR [ (1, _306, _311) (28, _307, _309) (-14, _307) (-14, _309) (-65536, _312) (-1, _313) 65535 ]", + "EXPR [ (-1, _312) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (28, _309, _307) (1, _311, _306) (-14, _307) (-14, _309) 14 ], EXPR [ 32768 ]], outputs: [_314, _315]", + "BLACKBOX::RANGE [(_314, 1)] []", + "BLACKBOX::RANGE [(_315, 15)] []", + "EXPR [ (1, _306, _311) (28, _307, _309) (-14, _307) (-14, _309) (-32768, _314) (-1, _315) 14 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (28, _309, _307) (1, _311, _306) (-14, _307) (-14, _309) 131070 ], EXPR [ 131072 ]], outputs: [_316, _317]", + "BLACKBOX::RANGE [(_316, 1)] []", + "BLACKBOX::RANGE [(_317, 17)] []", + "EXPR [ (1, _306, _311) (28, _307, _309) (-14, _307) (-14, _309) (-131072, _316) (-1, _317) 131070 ]", + "EXPR [ (2, _314, _316) (-1, _314) (-1, _316) (-1, _318) 1 ]", + "EXPR [ (1, _306, _311) (28, _307, _309) (-14, _307) (-14, _309) (-1, _319) 14 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _318, _319) 0 ], EXPR [ 5 ], EXPR [ 2 ]], outputs: [[_320, _321, _322, _323, _324]]", + "BLACKBOX::RANGE [(_320, 1)] []", + "BLACKBOX::RANGE [(_321, 1)] []", + "BLACKBOX::RANGE [(_322, 1)] []", + "BLACKBOX::RANGE [(_323, 1)] []", + "BLACKBOX::RANGE [(_324, 1)] []", + "EXPR [ (1, _318, _319) (-1, _320) (-2, _321) (-4, _322) (-8, _323) (-16, _324) 0 ]", + "EXPR [ (1, _324, _324) (2, _324) (-1, _325) 1 ]", + "EXPR [ (-1, _323) (-1, _326) 1 ]", + "EXPR [ (2, _323, _325) (1, _325, _326) (-1, _327) 0 ]", + "EXPR [ (1, _327, _327) (-1, _328) 0 ]", + "EXPR [ (-1, _322) (-1, _329) 1 ]", + "EXPR [ (2, _322, _328) (1, _328, _329) (-1, _330) 0 ]", + "EXPR [ (1, _330, _330) (-1, _331) 0 ]", + "EXPR [ (-1, _321) (-1, _332) 1 ]", + "EXPR [ (2, _321, _331) (1, _331, _332) (-1, _333) 0 ]", + "EXPR [ (1, _333, _333) (-1, _334) 0 ]", + "EXPR [ (-1, _320) (-1, _335) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _334, _320) (1, _334, _335) 0 ], EXPR [ 32768 ]], outputs: [_336, _337]", + "BLACKBOX::RANGE [(_336, 1)] []", + "BLACKBOX::RANGE [(_337, 15)] []", + "EXPR [ (2, _320, _334) (-1, _488) 0 ]", + "EXPR [ (1, _334, _335) (-1, _489) 0 ]", + "EXPR [ (-32768, _336) (-1, _337) (1, _488) (1, _489) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _276) 0 ], EXPR [ 32768 ]], outputs: [_338, _339]", + "BLACKBOX::RANGE [(_338, 1)] []", + "BLACKBOX::RANGE [(_339, 15)] []", + "EXPR [ (1, _276) (-32768, _338) (-1, _339) 0 ]", + "EXPR [ (-1, _340) (-1, _488) (-1, _489) 32768 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _334, _320) (1, _334, _335) (2, _340, _336) 0 ]], outputs: [_341]", + "EXPR [ (2, _336, _340) (-1, _342) (1, _488) (1, _489) 0 ]", + "EXPR [ (1, _341, _342) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _276, _338) (1, _276) (65536, _338) 0 ], EXPR [ (1, _342) 0 ]], outputs: [_343, _344]", + "BLACKBOX::RANGE [(_343, 16)] []", + "BLACKBOX::RANGE [(_344, 16)] []", + "EXPR [ (1, _342) (-1, _344) (-1, _345) -1 ]", + "BLACKBOX::RANGE [(_345, 16)] []", + "EXPR [ (-2, _276, _338) (-1, _342, _343) (1, _276) (65536, _338) (-1, _344) 0 ]", + "EXPR [ (-1, _343) (-1, _346) 32768 ]", + "EXPR [ (-2, _336, _338) (1, _336) (1, _338) (-1, _347) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _343) 0 ]], outputs: [_348]", + "EXPR [ (1, _343, _348) (1, _349) -1 ]", + "EXPR [ (1, _343, _349) 0 ]", + "EXPR [ (2, _346, _347) (1, _343) (-1, _350) 0 ]", + "EXPR [ (-1, _349) (-1, _351) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _344) 0 ]], outputs: [_352]", + "EXPR [ (1, _344, _352) (1, _353) -1 ]", + "EXPR [ (1, _344, _353) 0 ]", + "EXPR [ (-2, _338, _344) (65536, _338) (1, _344) (-1, _354) 0 ]", + "EXPR [ (-1, _353) (-1, _355) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _273, _271) (1, _350, _351) (1, _271) (1, _273) 131071 ], EXPR [ 65536 ]], outputs: [_356, _357]", + "BLACKBOX::RANGE [(_356, 2)] []", + "BLACKBOX::RANGE [(_357, 16)] []", + "EXPR [ (-2, _271, _273) (1, _350, _351) (1, _271) (1, _273) (-65536, _356) (-1, _357) 131071 ]", + "EXPR [ (131070, _271, _273) (-65535, _271) (-65535, _273) (-1, _358) 65535 ]", + "EXPR [ (-1, _318) (-1, _359) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _318, _357) (1, _358, _359) 0 ], EXPR [ 65536 ]], outputs: [_360, _361]", + "BLACKBOX::RANGE [(_360, 1)] []", + "EXPR [ (1, _318, _357) (1, _358, _359) (-65536, _360) (-1, _361) 0 ]", + "EXPR [ (1, _361) -65535 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _2) 131072 ], EXPR [ 65536 ]], outputs: [_362, _363]", + "BLACKBOX::RANGE [(_362, 2)] []", + "BLACKBOX::RANGE [(_363, 16)] []", + "EXPR [ (-1, _2) (-65536, _362) (-1, _363) 131072 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 32768 ], EXPR [ 65536 ]], outputs: [_364, _365]", + "BLACKBOX::RANGE [(_364, 1)] []", + "BLACKBOX::RANGE [(_365, 16)] []", + "EXPR [ (1, _2) (-65536, _364) (-1, _365) 32768 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _363) 32768 ], EXPR [ 65536 ]], outputs: [_366, _367]", + "BLACKBOX::RANGE [(_366, 1)] []", + "BLACKBOX::RANGE [(_367, 16)] []", + "EXPR [ (1, _363) (-65536, _366) (-1, _367) 32768 ]", + "EXPR [ (-1, _364, _366) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _363) 0 ], EXPR [ 32768 ]], outputs: [_368, _369]", + "BLACKBOX::RANGE [(_368, 1)] []", + "BLACKBOX::RANGE [(_369, 15)] []", + "EXPR [ (1, _363) (-32768, _368) (-1, _369) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _363) 131072 ], EXPR [ 131072 ]], outputs: [_370, _371]", + "BLACKBOX::RANGE [(_370, 1)] []", + "BLACKBOX::RANGE [(_371, 17)] []", + "EXPR [ (1, _363) (-131072, _370) (-1, _371) 131072 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _370, _368) (1, _363) (-1, _368) (-1, _370) 1 ], EXPR [ 65536 ]], outputs: [_372, _373]", + "BLACKBOX::RANGE [(_372, 1)] []", + "BLACKBOX::RANGE [(_373, 16)] []", + "EXPR [ (2, _368, _370) (1, _363) (-1, _368) (-1, _370) (-65536, _372) (-1, _373) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _334, _320) (1, _334, _335) 0 ], EXPR [ 32768 ]], outputs: [_374, _375]", + "BLACKBOX::RANGE [(_374, 1)] []", + "BLACKBOX::RANGE [(_375, 15)] []", + "EXPR [ (-32768, _374) (-1, _375) (1, _488) (1, _489) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _373) 0 ], EXPR [ 32768 ]], outputs: [_376, _377]", + "BLACKBOX::RANGE [(_376, 1)] []", + "BLACKBOX::RANGE [(_377, 15)] []", + "EXPR [ (1, _373) (-32768, _376) (-1, _377) 0 ]", + "EXPR [ (-1, _378) (-1, _488) (-1, _489) 32768 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _334, _320) (1, _334, _335) (2, _378, _374) 0 ]], outputs: [_379]", + "EXPR [ (2, _374, _378) (-1, _380) (1, _488) (1, _489) 0 ]", + "EXPR [ (1, _379, _380) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _373, _376) (1, _373) (65536, _376) 0 ], EXPR [ (1, _380) 0 ]], outputs: [_381, _382]", + "BLACKBOX::RANGE [(_381, 16)] []", + "BLACKBOX::RANGE [(_382, 16)] []", + "EXPR [ (1, _380) (-1, _382) (-1, _383) -1 ]", + "BLACKBOX::RANGE [(_383, 16)] []", + "EXPR [ (-2, _373, _376) (-1, _380, _381) (1, _373) (65536, _376) (-1, _382) 0 ]", + "EXPR [ (-1, _381) (-1, _384) 32768 ]", + "EXPR [ (-2, _374, _376) (1, _374) (1, _376) (-1, _385) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _381) 0 ]], outputs: [_386]", + "EXPR [ (1, _381, _386) (1, _387) -1 ]", + "EXPR [ (1, _381, _387) 0 ]", + "EXPR [ (2, _384, _385) (1, _381) (-1, _388) 0 ]", + "EXPR [ (-1, _387) (-1, _389) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _382) 0 ]], outputs: [_390]", + "EXPR [ (1, _382, _390) (1, _391) -1 ]", + "EXPR [ (1, _382, _391) 0 ]", + "EXPR [ (-2, _376, _382) (65536, _376) (1, _382) (-1, _392) 0 ]", + "EXPR [ (-1, _391) (-1, _393) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _370, _368) (1, _388, _389) (1, _368) (1, _370) 131071 ], EXPR [ 65536 ]], outputs: [_394, _395]", + "BLACKBOX::RANGE [(_394, 2)] []", + "BLACKBOX::RANGE [(_395, 16)] []", + "EXPR [ (-2, _368, _370) (1, _388, _389) (1, _368) (1, _370) (-65536, _394) (-1, _395) 131071 ]", + "EXPR [ (131070, _368, _370) (-65535, _368) (-65535, _370) (-1, _396) 65535 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _318, _395) (1, _396, _359) 0 ], EXPR [ 65536 ]], outputs: [_397, _398]", + "BLACKBOX::RANGE [(_397, 1)] []", + "EXPR [ (1, _318, _395) (1, _359, _396) (-65536, _397) (-1, _398) 0 ]", + "EXPR [ (1, _398) 0 ]", "unconstrained func 0", "[Const { destination: Direct(10), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(11), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(10), offset_address: Direct(11) }, BinaryFieldOp { destination: Direct(2), op: IntegerDiv, lhs: Direct(0), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Mul, lhs: Direct(2), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Sub, lhs: Direct(0), rhs: Direct(1) }, Mov { destination: Direct(0), source: Direct(2) }, Stop { return_data: HeapVector { pointer: Direct(11), size: Direct(10) } }]", "unconstrained func 1", @@ -574,10 +707,10 @@ expression: artifact "unconstrained func 2", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "pdnLThtJFIDhd/GaRZ9b1al5ldEocogTIVmAHIg0ivLu09Wn/1wWs2lvfH5wzhcwLmPs76dPl4/vXz48PX9++Xr66+/vp4+3p+v16cuH68vj+e3p5Xn97PcfDyc+/PB2u1zWT51+u37dej3fLs9vp7+e36/Xh9O38/V9+0dfX8/P23w739Zrl4fT5fnTOlfw89P1MuvHw6/t5f9XZbF9WeTXehza70f2Tdi3vG/f/cj+yH1flzv3RQ7sqwb7du/+kdvf1Pd9O/T/m+TPfb1z/8jP30LZb+2+/X7k63fj9nM/cvt54/x4P3L+PH/u57hvfxy5/4Rw/kLu3Fc7sm+dfb93/8jtF40H32hH7j/ROb+Rcuf+ka+//Xz8bsud+xJH9o3brx16/P59/9DX3/j5t2537h95/GqD268vRx6/uvL9d9X79s3u3P/z+/9n/ej8+HT74xnPyddfmQ+n2C7bdtm3y9wux3YpSw2poTWsRgFSghQhZUghUoqWoqVoKVqKlqKlaClaipaipVgpVoqVYqVYKVaKlWKlWClWipfipXgpXoqX4qV4KV6Kl+KlRCmxKusvrViV9b4TVsNrRI1Wo9fIGquy/rJqq7I+ZjSpoTWshteIGq1Gr5E1xjZ6Kb2UXkovpZfSV6WtY1XWM9J7jawxtpFLDamhNVZlfVKQqzLWETVajV5j3i7rHS9HzbHsU/ap+7R9+j5jn22ffZ+7N3ZPloUQQgkjnAiiEZ1IAlmQBVmQBVmQBVmQBVmQBVmRFVmRFVmRFVmRFVmRFdmQDdmQDdmQDdmQDdmQDdmRHdmRHdmRHdmRHdmRHTmQAzmQAzmQAzmQAzmQA7khN+SG3JAbckNuyA25ITfkjjyPlWwPbFPWGUY4EUQjOpHE2GMetAohkBM5kRM5kRM5kRN5IA/kgTyQB/JAHsgDeSCPXdZlIYRQwggngmhEJ5JAFmRBFmRBFmRBFmRBFmRBVmRFVmRFVmRFVmRFVmRFNmRDNmRDNmRDNmRDNmRDdmRHdmRHdmRHdmRHdmRHDuRADuRADuTtDNqMKbcZnUhi7LGdwS2EUGLKfcaUc0YQjehEEmOP7QxuIYQSRiB35I7ckTtyR07kRE7kRE7kRE7kRE7kRB7IA3kgD+SBPJAH8nYGx4ycL4PMGBU2z2CFEEoY4UQQjehEEsiCLMiCLMiCLMiCLMiCLMiKrMiKrMiKrMiKrMiKrMiGbMiGbMiGbMiGbMiGbMiO7MiO7MiO7MiO7MiO7MiBHMiBHMiBHMiBHMiBHMgNuSE35IbckBtyQ27I8wzq9gR6yjqfQi+EEEoY4UQQjehEEsiJnMjzDKrNMMKJIBrRiSSm7POJ/pRjhhBKGOFEEI3oRBKjwpeFEEIJI5wIYsptxpT7jCTGHtsZ3EIIJYxwIogp54wpjxlJjD22M7iFEEoY4UQQjUBWZEU2ZEM2ZEM2ZEM2ZEOeZ3C+duDzDNr2d9gyXw6dIYQSRjgRRCM6kcTYI5ADOZC3P99shhNBNKITSYw95hmsEEIJ5IbckBtyQ27IDbkjd+SO3JE7ckfuyB25I3fkRE7kRE7kRE7kRE7kRE7kgTyQB/JAHsgDeSAP5IE8djnmGbT5+tS38+3p/PF6+Vpv33x+f3787d2ct39fuYb3e15vL4+XT++3y3wdZLtufWXkPw==", + "debug_symbols": "rdrNbhNJFEDhd/E6i77/VfMqoxEKYFCkKKCQII0Q7z5dXXUysJhNeza+h5j7EccuJ3b4cfl4ff/6+d3D06cv3y5//Pnj8v754fHx4fO7xy8f7l8evjztH/3x8+7CH9+9PF+v+4cuv1y/b329f74+vVz+eHp9fLy7fL9/fD3+0rev90/HfLl/3q/d7i7Xp4/73MFPD4/XUT/v/t3e/ntVNl/LIvK2Hqf225l9U/at37bvcWa/97Wv2437oif2VZN9u3X/zNffNNa+md24X2f2pb/tt9v23U/s+8bXz+XM7Xfj9rufuf883vZTbtw/c368Gfvtxv1+5vzExv0XcuO+nvn6xdvzR9iZx094sR92235uZ/br7fa3U7e//H/bP3P+c2trP0+dv9z0bd9v3D/z+E/j/ku3G/fPPP9lcv6ythv388x+5/OvU98/f9mXM59/vX3/qVPfv8o5PxV1236e+vfr7fZXv22/5W37/ffz/9f+p/sPD8+//cR68f1HnrtLHJd5XNZx2Y7LflzKNofMoXPYHBOQKcgkZBoyEZmKTkWnolPRqehUdCo6FZ2KTkWnYlOxqdhUbCo2FZuKTcWmYlOxqfhUfCo+FZ+KT8Wn4ruyP6P4ruwHy9sc/RixzSFz6Bw2h8+xK/sTauzK/riOmqPN0Y+R2xwyh85hc/gcMceu7D/d5K7sd3K2OfoxaptD5tA5bI5d2Z+Va9yi/aFTuWat2dbsc7ZtTVlT17Q1fc3lteW15bXlteX15fXl9eGNB5et6WvGmrlmrdnW7HPKthFCKGGEE0EkUUQjkAVZkAVZkAVZkAVZkAVZkBVZkRVZkRVZkRVZkRVZkQ3ZkA3ZkA3ZkA3ZkA3ZkB3ZkR3ZkR3ZkR3ZkR3ZkQM5kAM5kAM5kAM5kAM5kBM5kRM5kRM5kRM5kRM5kQu5kAu5kAu5kAu5kAu5kBtyQ27IDfk4dDpiyDYiiSIaMWQfz7wbIYQSQ44RTgSRRBGN6DP0OIM5Ysg1QgkjnAgiiSIa0VccZ/AIZEEWZEEWZEEWZEEWZEVWZEVWZEVWZEVWZEVWZEM2ZEM25OMMthFD7iOSKKIRfcVxBo8QQgkjnEB2ZEd2ZEcO5EAO5EAO5EAO5EAO5EBO5ERO5ERO5ERO5ERO5EQu5EIu5EIu5EIu5EIu5EJuyA25ITfkhtyQG3JDbsgNuSN35I7ckTtyR+7IHbkj9yXbthFCKGHjDbARPt7JGhFEEkU0oq8YZ3CGEEoYgSzIgjzOoOqIRvQV4wzOEEIJI4ZsI4bsI5IoohF9xTiDM4RQwoghx4ggkiiiEX3FOIMzhFDCCGRHdmRHdmRHDuRADuRADuRADuRADuRATuRETuRETuRETuRETuRELuRCLuRCLuRCLuRxBsd7nDbOoNaIvmKcQW0jhFDCCCeCSKKIRvQVHbkjd+SO3JE7ckfuyB25L9m3jRBCCSOcCCKJIhqBLMiCLMiCLMiCLMiCfJzBPmK8atnGy52NEEIJI5wIIokiGoFsyIZsyIZsyIZsyIZsyIbsyI7syI7syI7syI7syI4cyIF8vJI7XgIOebz6O17NHRFEEkU0oq8YZ3CGEEogJ3IiJ3IiJ3IiF3IhF3IhjzNo48XqOIPmI5IoohFDjvECdyOEUMIIJ4JIYsg5Ysg1oq8YZ3CGEEoY4UQQSRSB3Jcc20YIoYQRTgSRRBGNQBZkQRZkQRZkQRZkQRZkQVZkRVZkRVZkRVZkRVZkRTZkQzZkQzZkQzZkQzZkQ3ZkR3ZkR3ZkR3ZkR3ZkRw7kQA7kQA7kQA7kQA7kQE7k4wy2EUPuI4xwIogkimhEX3GcwSOEQC7kQh5n0LcRSRTRiL5inMEZQihhhBPIDbkhN+SG3JE7ckfuyB25I3fkjtyR+5Jz2wghlDDCiSCSKKIRyIIsyIIsyIIsyIIsyIIsyIqsyIqsyIo8zqCPd1S/3z8/3L9/vH6bv/D/9Pr04Zff/7/8/ZVr+B8CX5+/fLh+fH2+jndej+v292L/AQ==", "file_map": { "50": { - "source": "fn main(x: u64, y: u8, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176, superseded by issue #8791\n assert(u >> (x as u8) == -1);\n assert(z >> (x as u8) == -1);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n\n assert(z >> 16 == -1);\n assert(-z >> x as u8 == 0);\n}\n", + "source": "fn main(x: u64, y: u64, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176, superseded by issue #8791\n assert(u >> (x as i64 - 2) == -1);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> a == 32);\n a = -a;\n assert(a << 6 == -64);\n assert(a << -a == -2);\n\n assert(x >> (x - 1) == 0);\n\n assert_eq(z >> 3, -97);\n\n assert(z >> 14 == -1);\n let rhs = (if x as i16 > 14 { 14 } else { x as i16 });\n assert(z >> rhs == -1);\n assert(-z >> rhs == 0);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_0.snap index 1767192b8eb..7755aac6b8a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_0.snap @@ -21,7 +21,7 @@ expression: artifact "type": { "kind": "integer", "sign": "unsigned", - "width": 8 + "width": 64 }, "visibility": "private" }, @@ -50,31 +50,39 @@ expression: artifact "error_kind": "string", "string": "attempt to subtract with overflow" }, - "5795655218219125583": { + "6668324276689745315": { + "error_kind": "string", + "string": "Field failed to decompose into specified 4 limbs" + }, + "13958753312450585022": { "error_kind": "string", - "string": "Field failed to decompose into specified 8 limbs" + "string": "Field failed to decompose into specified 7 limbs" }, "14514982005979867414": { "error_kind": "string", "string": "attempt to bit-shift with overflow" + }, + "16061458491050355795": { + "error_kind": "string", + "string": "Field failed to decompose into specified 5 limbs" } } }, "bytecode": [ "func 0", - "current witness index : _416", + "current witness index : _489", "private parameters indices : [_0, _1, _2, _3]", "public parameters indices : []", "return value indices : []", "BLACKBOX::RANGE [(_0, 64)] []", - "BLACKBOX::RANGE [(_1, 8)] []", + "BLACKBOX::RANGE [(_1, 64)] []", "BLACKBOX::RANGE [(_2, 16)] []", "BLACKBOX::RANGE [(_3, 64)] []", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 224 ], EXPR [ 256 ]], outputs: [_4, _5]", - "BLACKBOX::RANGE [(_4, 1)] []", - "BLACKBOX::RANGE [(_5, 8)] []", - "EXPR [ (1, _1) (-256, _4) (-1, _5) 224 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_6, _7, _8, _9, _10, _11, _12, _13]]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 18446744073709551552 ], EXPR [ 18446744073709551616 ]], outputs: [_4, _5]", + "BLACKBOX::RANGE [(_5, 64)] []", + "EXPR [ (1, _1) (-18446744073709551616, _4) (-1, _5) 18446744073709551552 ]", + "EXPR [ (-1, _4) 0 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1) 0 ], EXPR [ 7 ], EXPR [ 2 ]], outputs: [[_6, _7, _8, _9, _10, _11, _12]]", "BLACKBOX::RANGE [(_6, 1)] []", "BLACKBOX::RANGE [(_7, 1)] []", "BLACKBOX::RANGE [(_8, 1)] []", @@ -82,112 +90,121 @@ expression: artifact "BLACKBOX::RANGE [(_10, 1)] []", "BLACKBOX::RANGE [(_11, 1)] []", "BLACKBOX::RANGE [(_12, 1)] []", - "BLACKBOX::RANGE [(_13, 1)] []", - "EXPR [ (1, _1) (-1, _6) (-2, _7) (-4, _8) (-8, _9) (-16, _10) (-32, _11) (-64, _12) (-128, _13) 0 ]", - "EXPR [ (1, _13, _13) (2, _13) (-1, _14) 1 ]", - "EXPR [ (-1, _12) (-1, _15) 1 ]", - "EXPR [ (2, _12, _14) (1, _14, _15) (-1, _16) 0 ]", - "EXPR [ (1, _16, _16) (-1, _17) 0 ]", - "EXPR [ (-1, _11) (-1, _18) 1 ]", - "EXPR [ (2, _11, _17) (1, _17, _18) (-1, _19) 0 ]", - "EXPR [ (1, _19, _19) (-1, _20) 0 ]", - "EXPR [ (-1, _10) (-1, _21) 1 ]", - "EXPR [ (2, _10, _20) (1, _20, _21) (-1, _22) 0 ]", - "EXPR [ (1, _22, _22) (-1, _23) 0 ]", - "EXPR [ (-1, _9) (-1, _24) 1 ]", - "EXPR [ (2, _9, _23) (1, _23, _24) (-1, _25) 0 ]", - "EXPR [ (1, _25, _25) (-1, _26) 0 ]", - "EXPR [ (-1, _8) (-1, _27) 1 ]", - "EXPR [ (2, _8, _26) (1, _26, _27) (-1, _28) 0 ]", - "EXPR [ (1, _28, _28) (-1, _29) 0 ]", - "EXPR [ (-1, _7) (-1, _30) 1 ]", - "EXPR [ (2, _7, _29) (1, _29, _30) (-1, _31) 0 ]", - "EXPR [ (1, _31, _31) (-1, _32) 0 ]", - "EXPR [ (-1, _6) (-1, _33) 1 ]", - "EXPR [ (-1, _4) (-1, _34) 1 ]", - "EXPR [ (2, _6, _32) (1, _32, _33) (-1, _35) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (64, _34, _35) 0 ], EXPR [ 4294967296 ]], outputs: [_36, _37]", - "BLACKBOX::RANGE [(_36, 222)] []", - "EXPR [ (64, _34, _35) (-4294967296, _36) (-1, _37) 0 ]", - "EXPR [ (-1, _36) (-1, _38) 5096253676302562286669017222071363378443840053029366383258766538131 ]", - "BLACKBOX::RANGE [(_38, 222)] []", - "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _36) 5096253676302562286669017222071363378443840053029366383258766538131 ]], outputs: [_39]", - "EXPR [ (-1, _36, _39) (5096253676302562286669017222071363378443840053029366383258766538131, _39) (1, _40) -1 ]", - "EXPR [ (-1, _36, _40) (5096253676302562286669017222071363378443840053029366383258766538131, _40) 0 ]", - "EXPR [ (1, _37, _40) (268435455, _40) (-1, _41) 0 ]", - "BLACKBOX::RANGE [(_41, 32)] []", - "EXPR [ (1, _34) -1 ]", - "EXPR [ (1, _37) -128 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _35) 0 ]], outputs: [_42]", - "EXPR [ (1, _35, _42) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ 64 ], EXPR [ (1, _35) 0 ]], outputs: [_43, _44]", - "BLACKBOX::RANGE [(_44, 32)] []", - "EXPR [ (1, _35) (-1, _44) (-1, _45) -1 ]", - "BLACKBOX::RANGE [(_45, 32)] []", - "EXPR [ (-1, _35, _43) (-1, _44) 64 ]", - "EXPR [ (1, _43) -32 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 192 ], EXPR [ 256 ]], outputs: [_46, _47]", - "BLACKBOX::RANGE [(_47, 8)] []", - "EXPR [ (1, _1) (-256, _46) (-1, _47) 192 ]", - "EXPR [ (-1, _35, _46) (1, _35) (-1, _48) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0, _48) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_49, _50]", - "BLACKBOX::RANGE [(_49, 190)] []", - "EXPR [ (1, _0, _48) (-18446744073709551616, _49) (-1, _50) 0 ]", - "EXPR [ (-1, _49) (-1, _51) 1186564023676924939888766319973246049704924238154051448977 ]", - "BLACKBOX::RANGE [(_51, 190)] []", - "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _49) 1186564023676924939888766319973246049704924238154051448977 ]], outputs: [_52]", - "EXPR [ (-1, _49, _52) (1186564023676924939888766319973246049704924238154051448977, _52) (1, _53) -1 ]", - "EXPR [ (-1, _49, _53) (1186564023676924939888766319973246049704924238154051448977, _53) 0 ]", - "EXPR [ (1, _50, _53) (4331911350818177023, _53) (-1, _54) 0 ]", - "BLACKBOX::RANGE [(_54, 63)] []", - "EXPR [ (-1, _46) 0 ]", - "EXPR [ (1, _50) -128 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _35) 0 ]], outputs: [_55]", - "EXPR [ (1, _35, _55) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _35) 0 ]], outputs: [_56, _57]", - "BLACKBOX::RANGE [(_57, 64)] []", - "EXPR [ (1, _35) (-1, _57) (-1, _58) -1 ]", - "BLACKBOX::RANGE [(_58, 64)] []", - "EXPR [ (-1, _35, _56) (1, _0) (-1, _57) 0 ]", - "EXPR [ (1, _56) -32 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 256 ]], outputs: [_59, _60]", - "BLACKBOX::RANGE [(_59, 56)] []", - "BLACKBOX::RANGE [(_60, 8)] []", - "EXPR [ (1, _0) (-256, _59) (-1, _60) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _60) 192 ], EXPR [ 256 ]], outputs: [_61, _62]", - "BLACKBOX::RANGE [(_61, 1)] []", - "BLACKBOX::RANGE [(_62, 8)] []", - "EXPR [ (1, _60) (-256, _61) (-1, _62) 192 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _61, _60) (1, _60) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_63, _64, _65, _66, _67, _68, _69, _70]]", - "BLACKBOX::RANGE [(_63, 1)] []", + "EXPR [ (1, _1) (-1, _6) (-2, _7) (-4, _8) (-8, _9) (-16, _10) (-32, _11) (-64, _12) 0 ]", + "EXPR [ (1, _12, _12) (2, _12) (-1, _13) 1 ]", + "EXPR [ (-1, _11) (-1, _14) 1 ]", + "EXPR [ (2, _11, _13) (1, _13, _14) (-1, _15) 0 ]", + "EXPR [ (1, _15, _15) (-1, _16) 0 ]", + "EXPR [ (-1, _10) (-1, _17) 1 ]", + "EXPR [ (2, _10, _16) (1, _16, _17) (-1, _18) 0 ]", + "EXPR [ (1, _18, _18) (-1, _19) 0 ]", + "EXPR [ (-1, _9) (-1, _20) 1 ]", + "EXPR [ (2, _9, _19) (1, _19, _20) (-1, _21) 0 ]", + "EXPR [ (1, _21, _21) (-1, _22) 0 ]", + "EXPR [ (-1, _8) (-1, _23) 1 ]", + "EXPR [ (2, _8, _22) (1, _22, _23) (-1, _24) 0 ]", + "EXPR [ (1, _24, _24) (-1, _25) 0 ]", + "EXPR [ (-1, _7) (-1, _26) 1 ]", + "EXPR [ (2, _7, _25) (1, _25, _26) (-1, _27) 0 ]", + "EXPR [ (1, _27, _27) (-1, _28) 0 ]", + "EXPR [ (-1, _6) (-1, _29) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (128, _28, _6) (64, _28, _29) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_30, _31]", + "BLACKBOX::RANGE [(_30, 190)] []", + "EXPR [ (128, _6, _28) (-1, _411) 0 ]", + "EXPR [ (64, _28, _29) (-1, _412) 0 ]", + "EXPR [ (-18446744073709551616, _30) (-1, _31) (1, _411) (1, _412) 0 ]", + "EXPR [ (-1, _30) (-1, _32) 1186564023676924939888766319973246049704924238154051448977 ]", + "BLACKBOX::RANGE [(_32, 190)] []", + "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _30) 1186564023676924939888766319973246049704924238154051448977 ]], outputs: [_33]", + "EXPR [ (-1, _30, _33) (1186564023676924939888766319973246049704924238154051448977, _33) (1, _34) -1 ]", + "EXPR [ (-1, _30, _34) (1186564023676924939888766319973246049704924238154051448977, _34) 0 ]", + "EXPR [ (1, _31, _34) (4331911350818177023, _34) (-1, _35) 0 ]", + "BLACKBOX::RANGE [(_35, 63)] []", + "EXPR [ (1, _31) -128 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _28, _6) (1, _28, _29) 0 ]], outputs: [_36]", + "EXPR [ (-1, _37) (-342003794872488675347600089769644923258568193756500536620284440415247007744, _411) (-342003794872488675347600089769644923258568193756500536620284440415247007744, _412) 0 ]", + "EXPR [ (1, _36, _37) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ 64 ], EXPR [ (1, _37) 0 ]], outputs: [_38, _39]", + "BLACKBOX::RANGE [(_39, 64)] []", + "EXPR [ (1, _37) (-1, _39) (-1, _40) -1 ]", + "BLACKBOX::RANGE [(_40, 64)] []", + "EXPR [ (-1, _37, _38) (-1, _39) 64 ]", + "EXPR [ (1, _38) -32 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0, _37) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_41, _42]", + "BLACKBOX::RANGE [(_41, 190)] []", + "EXPR [ (1, _0, _37) (-18446744073709551616, _41) (-1, _42) 0 ]", + "EXPR [ (-1, _41) (-1, _43) 1186564023676924939888766319973246049704924238154051448977 ]", + "BLACKBOX::RANGE [(_43, 190)] []", + "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _41) 1186564023676924939888766319973246049704924238154051448977 ]], outputs: [_44]", + "EXPR [ (-1, _41, _44) (1186564023676924939888766319973246049704924238154051448977, _44) (1, _45) -1 ]", + "EXPR [ (-1, _41, _45) (1186564023676924939888766319973246049704924238154051448977, _45) 0 ]", + "EXPR [ (1, _42, _45) (4331911350818177023, _45) (-1, _46) 0 ]", + "BLACKBOX::RANGE [(_46, 63)] []", + "EXPR [ (1, _42) -128 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _37) 0 ]], outputs: [_47]", + "EXPR [ (1, _37, _47) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _37) 0 ]], outputs: [_48, _49]", + "BLACKBOX::RANGE [(_49, 64)] []", + "EXPR [ (1, _37) (-1, _49) (-1, _50) -1 ]", + "BLACKBOX::RANGE [(_50, 64)] []", + "EXPR [ (-1, _37, _48) (1, _0) (-1, _49) 0 ]", + "EXPR [ (1, _48) -32 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 36893488147419103230 ], EXPR [ 18446744073709551616 ]], outputs: [_51, _52]", + "BLACKBOX::RANGE [(_51, 2)] []", + "BLACKBOX::RANGE [(_52, 64)] []", + "EXPR [ (1, _0) (-18446744073709551616, _51) (-1, _52) 36893488147419103230 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 9223372036854775808 ], EXPR [ 18446744073709551616 ]], outputs: [_53, _54]", + "BLACKBOX::RANGE [(_53, 1)] []", + "BLACKBOX::RANGE [(_54, 64)] []", + "EXPR [ (1, _0) (-18446744073709551616, _53) (-1, _54) 9223372036854775808 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _52) 9223372036854775808 ], EXPR [ 18446744073709551616 ]], outputs: [_55, _56]", + "BLACKBOX::RANGE [(_55, 1)] []", + "BLACKBOX::RANGE [(_56, 64)] []", + "EXPR [ (1, _52) (-18446744073709551616, _55) (-1, _56) 9223372036854775808 ]", + "EXPR [ (1, _53) (-1, _55) (-1, _57) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _57) 0 ]], outputs: [_58]", + "EXPR [ (1, _57, _58) (1, _59) -1 ]", + "EXPR [ (1, _57, _59) 0 ]", + "EXPR [ (1, _53, _59) (-1, _53) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _52) 18446744073709551553 ], EXPR [ 18446744073709551616 ]], outputs: [_60, _61]", + "BLACKBOX::RANGE [(_61, 64)] []", + "EXPR [ (1, _52) (-18446744073709551616, _60) (-1, _61) 18446744073709551553 ]", + "EXPR [ (-1, _60) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _52) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_62, _63]", + "BLACKBOX::RANGE [(_62, 1)] []", + "BLACKBOX::RANGE [(_63, 63)] []", + "EXPR [ (1, _52) (-9223372036854775808, _62) (-1, _63) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _52) 36893488147419103168 ], EXPR [ 36893488147419103232 ]], outputs: [_64, _65]", "BLACKBOX::RANGE [(_64, 1)] []", - "BLACKBOX::RANGE [(_65, 1)] []", - "BLACKBOX::RANGE [(_66, 1)] []", + "BLACKBOX::RANGE [(_65, 65)] []", + "EXPR [ (1, _52) (-36893488147419103232, _64) (-1, _65) 36893488147419103168 ]", + "EXPR [ (2, _62, _64) (-1, _62) (-1, _64) (-1, _66) 1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _66, _52) 0 ], EXPR [ 7 ], EXPR [ 2 ]], outputs: [[_67, _68, _69, _70, _71, _72, _73]]", "BLACKBOX::RANGE [(_67, 1)] []", "BLACKBOX::RANGE [(_68, 1)] []", "BLACKBOX::RANGE [(_69, 1)] []", "BLACKBOX::RANGE [(_70, 1)] []", - "EXPR [ (-1, _60, _61) (1, _60) (-1, _63) (-2, _64) (-4, _65) (-8, _66) (-16, _67) (-32, _68) (-64, _69) (-128, _70) 0 ]", - "EXPR [ (1, _70, _70) (2, _70) (-1, _71) 1 ]", - "EXPR [ (-1, _69) (-1, _72) 1 ]", - "EXPR [ (2, _69, _71) (1, _71, _72) (-1, _73) 0 ]", - "EXPR [ (1, _73, _73) (-1, _74) 0 ]", - "EXPR [ (-1, _68) (-1, _75) 1 ]", - "EXPR [ (2, _68, _74) (1, _74, _75) (-1, _76) 0 ]", + "BLACKBOX::RANGE [(_71, 1)] []", + "BLACKBOX::RANGE [(_72, 1)] []", + "BLACKBOX::RANGE [(_73, 1)] []", + "EXPR [ (1, _52, _66) (-1, _67) (-2, _68) (-4, _69) (-8, _70) (-16, _71) (-32, _72) (-64, _73) 0 ]", + "EXPR [ (1, _73, _73) (2, _73) (-1, _74) 1 ]", + "EXPR [ (-1, _72) (-1, _75) 1 ]", + "EXPR [ (2, _72, _74) (1, _74, _75) (-1, _76) 0 ]", "EXPR [ (1, _76, _76) (-1, _77) 0 ]", - "EXPR [ (-1, _67) (-1, _78) 1 ]", - "EXPR [ (2, _67, _77) (1, _77, _78) (-1, _79) 0 ]", + "EXPR [ (-1, _71) (-1, _78) 1 ]", + "EXPR [ (2, _71, _77) (1, _77, _78) (-1, _79) 0 ]", "EXPR [ (1, _79, _79) (-1, _80) 0 ]", - "EXPR [ (-1, _66) (-1, _81) 1 ]", - "EXPR [ (2, _66, _80) (1, _80, _81) (-1, _82) 0 ]", + "EXPR [ (-1, _70) (-1, _81) 1 ]", + "EXPR [ (2, _70, _80) (1, _80, _81) (-1, _82) 0 ]", "EXPR [ (1, _82, _82) (-1, _83) 0 ]", - "EXPR [ (-1, _65) (-1, _84) 1 ]", - "EXPR [ (2, _65, _83) (1, _83, _84) (-1, _85) 0 ]", + "EXPR [ (-1, _69) (-1, _84) 1 ]", + "EXPR [ (2, _69, _83) (1, _83, _84) (-1, _85) 0 ]", "EXPR [ (1, _85, _85) (-1, _86) 0 ]", - "EXPR [ (-1, _64) (-1, _87) 1 ]", - "EXPR [ (2, _64, _86) (1, _86, _87) (-1, _88) 0 ]", + "EXPR [ (-1, _68) (-1, _87) 1 ]", + "EXPR [ (2, _68, _86) (1, _86, _87) (-1, _88) 0 ]", "EXPR [ (1, _88, _88) (-1, _89) 0 ]", - "EXPR [ (-1, _63) (-1, _90) 1 ]", + "EXPR [ (-1, _67) (-1, _90) 1 ]", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _3) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_91, _92]", "BLACKBOX::RANGE [(_91, 1)] []", "BLACKBOX::RANGE [(_92, 63)] []", @@ -200,19 +217,19 @@ expression: artifact "BLACKBOX::RANGE [(_95, 1)] []", "BLACKBOX::RANGE [(_96, 64)] []", "EXPR [ (2, _91, _93) (1, _3) (-1, _91) (-1, _93) (-18446744073709551616, _95) (-1, _96) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _89, _63) (1, _89, _90) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_97, _98]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _89, _67) (1, _89, _90) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_97, _98]", "BLACKBOX::RANGE [(_97, 1)] []", "BLACKBOX::RANGE [(_98, 63)] []", - "EXPR [ (2, _63, _89) (-1, _364) 0 ]", - "EXPR [ (1, _89, _90) (-1, _365) 0 ]", - "EXPR [ (-9223372036854775808, _97) (-1, _98) (1, _364) (1, _365) 0 ]", + "EXPR [ (2, _67, _89) (-1, _428) 0 ]", + "EXPR [ (1, _89, _90) (-1, _429) 0 ]", + "EXPR [ (-9223372036854775808, _97) (-1, _98) (1, _428) (1, _429) 0 ]", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _96) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_99, _100]", "BLACKBOX::RANGE [(_99, 1)] []", "BLACKBOX::RANGE [(_100, 63)] []", "EXPR [ (1, _96) (-9223372036854775808, _99) (-1, _100) 0 ]", - "EXPR [ (-1, _101) (-1, _364) (-1, _365) 9223372036854775808 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _89, _63) (1, _89, _90) (2, _101, _97) 0 ]], outputs: [_102]", - "EXPR [ (2, _97, _101) (-1, _103) (1, _364) (1, _365) 0 ]", + "EXPR [ (-1, _101) (-1, _428) (-1, _429) 9223372036854775808 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _89, _67) (1, _89, _90) (2, _101, _97) 0 ]], outputs: [_102]", + "EXPR [ (2, _97, _101) (-1, _103) (1, _428) (1, _429) 0 ]", "EXPR [ (1, _102, _103) -1 ]", "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _96, _99) (1, _96) (18446744073709551616, _99) 0 ], EXPR [ (1, _103) 0 ]], outputs: [_104, _105]", "BLACKBOX::RANGE [(_104, 64)] []", @@ -237,336 +254,452 @@ expression: artifact "BLACKBOX::RANGE [(_118, 64)] []", "EXPR [ (-2, _91, _93) (1, _111, _112) (1, _91) (1, _93) (-18446744073709551616, _117) (-1, _118) 36893488147419103231 ]", "EXPR [ (36893488147419103230, _91, _93) (-18446744073709551615, _91) (-18446744073709551615, _93) (-1, _119) 18446744073709551615 ]", - "EXPR [ (-1, _61, _118) (1, _61, _119) (1, _118) -18446744073709551615 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _60) 240 ], EXPR [ 256 ]], outputs: [_120, _121]", - "BLACKBOX::RANGE [(_120, 1)] []", - "BLACKBOX::RANGE [(_121, 8)] []", - "EXPR [ (1, _60) (-256, _120) (-1, _121) 240 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _120, _60) (1, _60) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_122, _123, _124, _125, _126, _127, _128, _129]]", - "BLACKBOX::RANGE [(_122, 1)] []", - "BLACKBOX::RANGE [(_123, 1)] []", - "BLACKBOX::RANGE [(_124, 1)] []", - "BLACKBOX::RANGE [(_125, 1)] []", - "BLACKBOX::RANGE [(_126, 1)] []", + "EXPR [ (-1, _66) (-1, _120) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _66, _118) (1, _119, _120) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_121, _122]", + "BLACKBOX::RANGE [(_121, 1)] []", + "EXPR [ (1, _66, _118) (1, _119, _120) (-18446744073709551616, _121) (-1, _122) 0 ]", + "EXPR [ (1, _122) -18446744073709551615 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 0 ], EXPR [ 256 ]], outputs: [_123, _124]", + "BLACKBOX::RANGE [(_123, 56)] []", + "BLACKBOX::RANGE [(_124, 8)] []", + "EXPR [ (1, _1) (-256, _123) (-1, _124) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 256 ]], outputs: [_125, _126]", + "BLACKBOX::RANGE [(_125, 56)] []", + "BLACKBOX::RANGE [(_126, 8)] []", + "EXPR [ (1, _0) (-256, _125) (-1, _126) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _126) 0 ], EXPR [ 256 ]], outputs: [_127, _128]", "BLACKBOX::RANGE [(_127, 1)] []", - "BLACKBOX::RANGE [(_128, 1)] []", + "BLACKBOX::RANGE [(_128, 8)] []", + "EXPR [ (2, _126) (-256, _127) (-1, _128) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _128) 0 ], EXPR [ 256 ]], outputs: [_129, _130]", "BLACKBOX::RANGE [(_129, 1)] []", - "EXPR [ (-1, _60, _120) (1, _60) (-1, _122) (-2, _123) (-4, _124) (-8, _125) (-16, _126) (-32, _127) (-64, _128) (-128, _129) 0 ]", - "EXPR [ (1, _129, _129) (2, _129) (-1, _130) 1 ]", - "EXPR [ (-1, _128) (-1, _131) 1 ]", - "EXPR [ (2, _128, _130) (1, _130, _131) (-1, _132) 0 ]", - "EXPR [ (1, _132, _132) (-1, _133) 0 ]", - "EXPR [ (-1, _127) (-1, _134) 1 ]", - "EXPR [ (2, _127, _133) (1, _133, _134) (-1, _135) 0 ]", - "EXPR [ (1, _135, _135) (-1, _136) 0 ]", - "EXPR [ (-1, _126) (-1, _137) 1 ]", - "EXPR [ (2, _126, _136) (1, _136, _137) (-1, _138) 0 ]", - "EXPR [ (1, _138, _138) (-1, _139) 0 ]", - "EXPR [ (-1, _125) (-1, _140) 1 ]", - "EXPR [ (2, _125, _139) (1, _139, _140) (-1, _141) 0 ]", - "EXPR [ (1, _141, _141) (-1, _142) 0 ]", - "EXPR [ (-1, _124) (-1, _143) 1 ]", - "EXPR [ (2, _124, _142) (1, _142, _143) (-1, _144) 0 ]", - "EXPR [ (1, _144, _144) (-1, _145) 0 ]", - "EXPR [ (-1, _123) (-1, _146) 1 ]", - "EXPR [ (2, _123, _145) (1, _145, _146) (-1, _147) 0 ]", - "EXPR [ (1, _147, _147) (-1, _148) 0 ]", - "EXPR [ (-1, _122) (-1, _149) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 32768 ]], outputs: [_150, _151]", - "BLACKBOX::RANGE [(_150, 1)] []", - "BLACKBOX::RANGE [(_151, 15)] []", - "EXPR [ (1, _2) (-32768, _150) (-1, _151) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 131072 ], EXPR [ 131072 ]], outputs: [_152, _153]", - "BLACKBOX::RANGE [(_152, 1)] []", - "BLACKBOX::RANGE [(_153, 17)] []", - "EXPR [ (1, _2) (-131072, _152) (-1, _153) 131072 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _152, _150) (1, _2) (-1, _150) (-1, _152) 1 ], EXPR [ 65536 ]], outputs: [_154, _155]", - "BLACKBOX::RANGE [(_154, 1)] []", - "BLACKBOX::RANGE [(_155, 16)] []", - "EXPR [ (2, _150, _152) (1, _2) (-1, _150) (-1, _152) (-65536, _154) (-1, _155) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _148, _122) (1, _148, _149) 0 ], EXPR [ 32768 ]], outputs: [_156, _157]", - "BLACKBOX::RANGE [(_156, 1)] []", - "BLACKBOX::RANGE [(_157, 15)] []", - "EXPR [ (2, _122, _148) (-1, _389) 0 ]", - "EXPR [ (1, _148, _149) (-1, _390) 0 ]", - "EXPR [ (-32768, _156) (-1, _157) (1, _389) (1, _390) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _155) 0 ], EXPR [ 32768 ]], outputs: [_158, _159]", + "EXPR [ (1, _128) (-256, _129) (-1, _130) 0 ]", + "EXPR [ (1, _130) -128 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _126) 0 ], EXPR [ 128 ]], outputs: [_131, _132]", + "BLACKBOX::RANGE [(_131, 1)] []", + "BLACKBOX::RANGE [(_132, 7)] []", + "EXPR [ (1, _126) (-128, _131) (-1, _132) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _126) 512 ], EXPR [ 512 ]], outputs: [_133, _134]", + "BLACKBOX::RANGE [(_133, 1)] []", + "BLACKBOX::RANGE [(_134, 9)] []", + "EXPR [ (1, _126) (-512, _133) (-1, _134) 512 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _133, _131) (1, _126) (-1, _131) (-1, _133) 1 ], EXPR [ 256 ]], outputs: [_135, _136]", + "BLACKBOX::RANGE [(_135, 1)] []", + "BLACKBOX::RANGE [(_136, 8)] []", + "EXPR [ (2, _131, _133) (1, _126) (-1, _131) (-1, _133) (-256, _135) (-1, _136) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _136) 0 ], EXPR [ 128 ]], outputs: [_137, _138]", + "BLACKBOX::RANGE [(_137, 1)] []", + "BLACKBOX::RANGE [(_138, 7)] []", + "EXPR [ (1, _136) (-128, _137) (-1, _138) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _136, _137) (1, _136) (256, _137) 0 ], EXPR [ 4 ]], outputs: [_139, _140]", + "BLACKBOX::RANGE [(_139, 6)] []", + "BLACKBOX::RANGE [(_140, 2)] []", + "EXPR [ (-2, _136, _137) (1, _136) (256, _137) (-4, _139) (-1, _140) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _139) 0 ]], outputs: [_141]", + "EXPR [ (1, _139, _141) (1, _142) -1 ]", + "EXPR [ (1, _139, _142) 0 ]", + "EXPR [ (-2, _137, _139) (256, _137) (1, _139) (-1, _143) 0 ]", + "EXPR [ (-1, _142) (-1, _144) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _140) 0 ]], outputs: [_145]", + "EXPR [ (1, _140, _145) (1, _146) -1 ]", + "EXPR [ (1, _140, _146) 0 ]", + "EXPR [ (-2, _137, _140) (256, _137) (1, _140) (-1, _147) 0 ]", + "EXPR [ (-1, _146) (-1, _148) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _133, _131) (1, _143, _144) (1, _131) (1, _133) 511 ], EXPR [ 256 ]], outputs: [_149, _150]", + "BLACKBOX::RANGE [(_149, 2)] []", + "EXPR [ (-2, _131, _133) (1, _143, _144) (1, _131) (1, _133) (-256, _149) (-1, _150) 511 ]", + "EXPR [ (1, _150) -16 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _124) 249 ], EXPR [ 256 ]], outputs: [_151, _152]", + "BLACKBOX::RANGE [(_152, 8)] []", + "EXPR [ (1, _124) (-256, _151) (-1, _152) 249 ]", + "EXPR [ (-1, _151) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _124) 0 ], EXPR [ 128 ]], outputs: [_153, _154]", + "BLACKBOX::RANGE [(_153, 1)] []", + "BLACKBOX::RANGE [(_154, 7)] []", + "EXPR [ (1, _124) (-128, _153) (-1, _154) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _124) 504 ], EXPR [ 512 ]], outputs: [_155, _156]", + "BLACKBOX::RANGE [(_155, 1)] []", + "BLACKBOX::RANGE [(_156, 9)] []", + "EXPR [ (1, _124) (-512, _155) (-1, _156) 504 ]", + "EXPR [ (2, _153, _155) (-1, _153) (-1, _155) (-1, _157) 1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _157, _124) 0 ], EXPR [ 4 ], EXPR [ 2 ]], outputs: [[_158, _159, _160, _161]]", "BLACKBOX::RANGE [(_158, 1)] []", - "BLACKBOX::RANGE [(_159, 15)] []", - "EXPR [ (1, _155) (-32768, _158) (-1, _159) 0 ]", - "EXPR [ (-1, _160) (-1, _389) (-1, _390) 32768 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _148, _122) (1, _148, _149) (2, _160, _156) 0 ]], outputs: [_161]", - "EXPR [ (2, _156, _160) (-1, _162) (1, _389) (1, _390) 0 ]", - "EXPR [ (1, _161, _162) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _155, _158) (1, _155) (65536, _158) 0 ], EXPR [ (1, _162) 0 ]], outputs: [_163, _164]", - "BLACKBOX::RANGE [(_163, 16)] []", - "BLACKBOX::RANGE [(_164, 16)] []", - "EXPR [ (1, _162) (-1, _164) (-1, _165) -1 ]", - "BLACKBOX::RANGE [(_165, 16)] []", - "EXPR [ (-2, _155, _158) (-1, _162, _163) (1, _155) (65536, _158) (-1, _164) 0 ]", - "EXPR [ (-1, _163) (-1, _166) 32768 ]", - "EXPR [ (-2, _156, _158) (1, _156) (1, _158) (-1, _167) 0 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _163) 0 ]], outputs: [_168]", - "EXPR [ (1, _163, _168) (1, _169) -1 ]", - "EXPR [ (1, _163, _169) 0 ]", - "EXPR [ (2, _166, _167) (1, _163) (-1, _170) 0 ]", - "EXPR [ (-1, _169) (-1, _171) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _164) 0 ]], outputs: [_172]", - "EXPR [ (1, _164, _172) (1, _173) -1 ]", - "EXPR [ (1, _164, _173) 0 ]", - "EXPR [ (-2, _158, _164) (65536, _158) (1, _164) (-1, _174) 0 ]", - "EXPR [ (-1, _173) (-1, _175) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _152, _150) (1, _170, _171) (1, _150) (1, _152) 131071 ], EXPR [ 65536 ]], outputs: [_176, _177]", - "BLACKBOX::RANGE [(_176, 2)] []", - "BLACKBOX::RANGE [(_177, 16)] []", - "EXPR [ (-2, _150, _152) (1, _170, _171) (1, _150) (1, _152) (-65536, _176) (-1, _177) 131071 ]", - "EXPR [ (131070, _150, _152) (-65535, _150) (-65535, _152) (-1, _178) 65535 ]", - "EXPR [ (-1, _120, _177) (1, _120, _178) (1, _177) -65535 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _60) 0 ], EXPR [ 256 ]], outputs: [_179, _180]", - "BLACKBOX::RANGE [(_179, 1)] []", - "BLACKBOX::RANGE [(_180, 8)] []", - "EXPR [ (2, _60) (-256, _179) (-1, _180) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _180) 0 ], EXPR [ 256 ]], outputs: [_181, _182]", - "BLACKBOX::RANGE [(_181, 1)] []", - "EXPR [ (1, _180) (-256, _181) (-1, _182) 0 ]", - "EXPR [ (1, _182) -128 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _60) 0 ], EXPR [ 128 ]], outputs: [_183, _184]", - "BLACKBOX::RANGE [(_183, 1)] []", - "BLACKBOX::RANGE [(_184, 7)] []", - "EXPR [ (1, _60) (-128, _183) (-1, _184) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _60) 512 ], EXPR [ 512 ]], outputs: [_185, _186]", - "BLACKBOX::RANGE [(_185, 1)] []", - "BLACKBOX::RANGE [(_186, 9)] []", - "EXPR [ (1, _60) (-512, _185) (-1, _186) 512 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _185, _183) (1, _60) (-1, _183) (-1, _185) 1 ], EXPR [ 256 ]], outputs: [_187, _188]", - "BLACKBOX::RANGE [(_187, 1)] []", - "BLACKBOX::RANGE [(_188, 8)] []", - "EXPR [ (2, _183, _185) (1, _60) (-1, _183) (-1, _185) (-256, _187) (-1, _188) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _188) 0 ], EXPR [ 128 ]], outputs: [_189, _190]", - "BLACKBOX::RANGE [(_189, 1)] []", - "BLACKBOX::RANGE [(_190, 7)] []", - "EXPR [ (1, _188) (-128, _189) (-1, _190) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _188, _189) (1, _188) (256, _189) 0 ], EXPR [ 4 ]], outputs: [_191, _192]", - "BLACKBOX::RANGE [(_191, 6)] []", - "BLACKBOX::RANGE [(_192, 2)] []", - "EXPR [ (-2, _188, _189) (1, _188) (256, _189) (-4, _191) (-1, _192) 0 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _191) 0 ]], outputs: [_193]", - "EXPR [ (1, _191, _193) (1, _194) -1 ]", - "EXPR [ (1, _191, _194) 0 ]", - "EXPR [ (-2, _189, _191) (256, _189) (1, _191) (-1, _195) 0 ]", - "EXPR [ (-1, _194) (-1, _196) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _192) 0 ]], outputs: [_197]", - "EXPR [ (1, _192, _197) (1, _198) -1 ]", - "EXPR [ (1, _192, _198) 0 ]", - "EXPR [ (-2, _189, _192) (256, _189) (1, _192) (-1, _199) 0 ]", - "EXPR [ (-1, _198) (-1, _200) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _185, _183) (1, _195, _196) (1, _183) (1, _185) 511 ], EXPR [ 256 ]], outputs: [_201, _202]", - "BLACKBOX::RANGE [(_201, 2)] []", - "EXPR [ (-2, _183, _185) (1, _195, _196) (1, _183) (1, _185) (-256, _201) (-1, _202) 511 ]", - "EXPR [ (1, _202) -16 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 248 ], EXPR [ 256 ]], outputs: [_203, _204]", - "BLACKBOX::RANGE [(_204, 8)] []", - "EXPR [ (1, _1) (-256, _203) (-1, _204) 248 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _203, _1) (1, _1) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_205, _206, _207, _208, _209, _210, _211, _212]]", - "BLACKBOX::RANGE [(_205, 1)] []", - "BLACKBOX::RANGE [(_206, 1)] []", - "BLACKBOX::RANGE [(_207, 1)] []", + "BLACKBOX::RANGE [(_159, 1)] []", + "BLACKBOX::RANGE [(_160, 1)] []", + "BLACKBOX::RANGE [(_161, 1)] []", + "EXPR [ (1, _124, _157) (-1, _158) (-2, _159) (-4, _160) (-8, _161) 0 ]", + "EXPR [ (1, _161, _161) (2, _161) (-1, _162) 1 ]", + "EXPR [ (-1, _160) (-1, _163) 1 ]", + "EXPR [ (2, _160, _162) (1, _162, _163) (-1, _164) 0 ]", + "EXPR [ (1, _164, _164) (-1, _165) 0 ]", + "EXPR [ (-1, _159) (-1, _166) 1 ]", + "EXPR [ (2, _159, _165) (1, _165, _166) (-1, _167) 0 ]", + "EXPR [ (1, _167, _167) (-1, _168) 0 ]", + "EXPR [ (-1, _158) (-1, _169) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _168, _158) (1, _168, _169) 0 ], EXPR [ 128 ]], outputs: [_170, _171]", + "BLACKBOX::RANGE [(_170, 1)] []", + "BLACKBOX::RANGE [(_171, 7)] []", + "EXPR [ (2, _158, _168) (-1, _444) 0 ]", + "EXPR [ (1, _168, _169) (-1, _445) 0 ]", + "EXPR [ (-128, _170) (-1, _171) (1, _444) (1, _445) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _136) 0 ], EXPR [ 128 ]], outputs: [_172, _173]", + "BLACKBOX::RANGE [(_172, 1)] []", + "BLACKBOX::RANGE [(_173, 7)] []", + "EXPR [ (1, _136) (-128, _172) (-1, _173) 0 ]", + "EXPR [ (-1, _174) (-1, _444) (-1, _445) 128 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _168, _158) (1, _168, _169) (2, _174, _170) 0 ]], outputs: [_175]", + "EXPR [ (2, _170, _174) (-1, _176) (1, _444) (1, _445) 0 ]", + "EXPR [ (1, _175, _176) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _136, _172) (1, _136) (256, _172) 0 ], EXPR [ (1, _176) 0 ]], outputs: [_177, _178]", + "BLACKBOX::RANGE [(_177, 8)] []", + "BLACKBOX::RANGE [(_178, 8)] []", + "EXPR [ (1, _176) (-1, _178) (-1, _179) -1 ]", + "BLACKBOX::RANGE [(_179, 8)] []", + "EXPR [ (-2, _136, _172) (-1, _176, _177) (1, _136) (256, _172) (-1, _178) 0 ]", + "EXPR [ (-1, _177) (-1, _180) 128 ]", + "EXPR [ (-2, _170, _172) (1, _170) (1, _172) (-1, _181) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _177) 0 ]], outputs: [_182]", + "EXPR [ (1, _177, _182) (1, _183) -1 ]", + "EXPR [ (1, _177, _183) 0 ]", + "EXPR [ (2, _180, _181) (1, _177) (-1, _184) 0 ]", + "EXPR [ (-1, _183) (-1, _185) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _178) 0 ]], outputs: [_186]", + "EXPR [ (1, _178, _186) (1, _187) -1 ]", + "EXPR [ (1, _178, _187) 0 ]", + "EXPR [ (-2, _172, _178) (256, _172) (1, _178) (-1, _188) 0 ]", + "EXPR [ (-1, _187) (-1, _189) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _133, _131) (1, _184, _185) (1, _131) (1, _133) 511 ], EXPR [ 256 ]], outputs: [_190, _191]", + "BLACKBOX::RANGE [(_190, 2)] []", + "BLACKBOX::RANGE [(_191, 8)] []", + "EXPR [ (-2, _131, _133) (1, _184, _185) (1, _131) (1, _133) (-256, _190) (-1, _191) 511 ]", + "EXPR [ (510, _131, _133) (-255, _131) (-255, _133) (-1, _192) 255 ]", + "EXPR [ (-1, _157) (-1, _193) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _157, _191) (1, _192, _193) 0 ], EXPR [ 256 ]], outputs: [_194, _195]", + "BLACKBOX::RANGE [(_194, 1)] []", + "EXPR [ (1, _157, _191) (1, _192, _193) (-256, _194) (-1, _195) 0 ]", + "EXPR [ (1, _195) -32 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _124) 512 ], EXPR [ 256 ]], outputs: [_196, _197]", + "BLACKBOX::RANGE [(_196, 2)] []", + "BLACKBOX::RANGE [(_197, 8)] []", + "EXPR [ (-1, _124) (-256, _196) (-1, _197) 512 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _124) 128 ], EXPR [ 256 ]], outputs: [_198, _199]", + "BLACKBOX::RANGE [(_198, 1)] []", + "BLACKBOX::RANGE [(_199, 8)] []", + "EXPR [ (1, _124) (-256, _198) (-1, _199) 128 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _197) 128 ], EXPR [ 256 ]], outputs: [_200, _201]", + "BLACKBOX::RANGE [(_200, 1)] []", + "BLACKBOX::RANGE [(_201, 8)] []", + "EXPR [ (1, _197) (-256, _200) (-1, _201) 128 ]", + "EXPR [ (-1, _198, _200) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (64, _197) 0 ], EXPR [ 256 ]], outputs: [_202, _203]", + "BLACKBOX::RANGE [(_202, 6)] []", + "BLACKBOX::RANGE [(_203, 8)] []", + "EXPR [ (64, _197) (-256, _202) (-1, _203) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _203) 0 ], EXPR [ 256 ]], outputs: [_204, _205]", + "BLACKBOX::RANGE [(_204, 1)] []", + "EXPR [ (1, _203) (-256, _204) (-1, _205) 0 ]", + "EXPR [ (1, _205) -192 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _197) 512 ], EXPR [ 256 ]], outputs: [_206, _207]", + "BLACKBOX::RANGE [(_206, 2)] []", + "BLACKBOX::RANGE [(_207, 8)] []", + "EXPR [ (-1, _197) (-256, _206) (-1, _207) 512 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _207) 128 ], EXPR [ 256 ]], outputs: [_208, _209]", "BLACKBOX::RANGE [(_208, 1)] []", - "BLACKBOX::RANGE [(_209, 1)] []", - "BLACKBOX::RANGE [(_210, 1)] []", - "BLACKBOX::RANGE [(_211, 1)] []", + "BLACKBOX::RANGE [(_209, 8)] []", + "EXPR [ (1, _207) (-256, _208) (-1, _209) 128 ]", + "EXPR [ (-1, _200, _208) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _207) 249 ], EXPR [ 256 ]], outputs: [_210, _211]", + "BLACKBOX::RANGE [(_211, 8)] []", + "EXPR [ (1, _207) (-256, _210) (-1, _211) 249 ]", + "EXPR [ (-1, _210) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _207) 0 ], EXPR [ 128 ]], outputs: [_212, _213]", "BLACKBOX::RANGE [(_212, 1)] []", - "EXPR [ (-1, _1, _203) (1, _1) (-1, _205) (-2, _206) (-4, _207) (-8, _208) (-16, _209) (-32, _210) (-64, _211) (-128, _212) 0 ]", - "EXPR [ (1, _212, _212) (2, _212) (-1, _213) 1 ]", - "EXPR [ (-1, _211) (-1, _214) 1 ]", - "EXPR [ (2, _211, _213) (1, _213, _214) (-1, _215) 0 ]", - "EXPR [ (1, _215, _215) (-1, _216) 0 ]", - "EXPR [ (-1, _210) (-1, _217) 1 ]", - "EXPR [ (2, _210, _216) (1, _216, _217) (-1, _218) 0 ]", - "EXPR [ (1, _218, _218) (-1, _219) 0 ]", - "EXPR [ (-1, _209) (-1, _220) 1 ]", - "EXPR [ (2, _209, _219) (1, _219, _220) (-1, _221) 0 ]", - "EXPR [ (1, _221, _221) (-1, _222) 0 ]", - "EXPR [ (-1, _208) (-1, _223) 1 ]", - "EXPR [ (2, _208, _222) (1, _222, _223) (-1, _224) 0 ]", - "EXPR [ (1, _224, _224) (-1, _225) 0 ]", - "EXPR [ (-1, _207) (-1, _226) 1 ]", - "EXPR [ (2, _207, _225) (1, _225, _226) (-1, _227) 0 ]", - "EXPR [ (1, _227, _227) (-1, _228) 0 ]", - "EXPR [ (-1, _206) (-1, _229) 1 ]", - "EXPR [ (2, _206, _228) (1, _228, _229) (-1, _230) 0 ]", - "EXPR [ (1, _230, _230) (-1, _231) 0 ]", - "EXPR [ (-1, _205) (-1, _232) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _231, _205) (1, _231, _232) 0 ], EXPR [ 128 ]], outputs: [_233, _234]", - "BLACKBOX::RANGE [(_233, 1)] []", - "BLACKBOX::RANGE [(_234, 7)] []", - "EXPR [ (2, _205, _231) (-1, _415) 0 ]", - "EXPR [ (1, _231, _232) (-1, _416) 0 ]", - "EXPR [ (-128, _233) (-1, _234) (1, _415) (1, _416) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _188) 0 ], EXPR [ 128 ]], outputs: [_235, _236]", - "BLACKBOX::RANGE [(_235, 1)] []", - "BLACKBOX::RANGE [(_236, 7)] []", - "EXPR [ (1, _188) (-128, _235) (-1, _236) 0 ]", - "EXPR [ (-1, _237) (-1, _415) (-1, _416) 128 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _231, _205) (1, _231, _232) (2, _237, _233) 0 ]], outputs: [_238]", - "EXPR [ (2, _233, _237) (-1, _239) (1, _415) (1, _416) 0 ]", - "EXPR [ (1, _238, _239) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _188, _235) (1, _188) (256, _235) 0 ], EXPR [ (1, _239) 0 ]], outputs: [_240, _241]", - "BLACKBOX::RANGE [(_240, 8)] []", - "BLACKBOX::RANGE [(_241, 8)] []", - "EXPR [ (1, _239) (-1, _241) (-1, _242) -1 ]", - "BLACKBOX::RANGE [(_242, 8)] []", - "EXPR [ (-2, _188, _235) (-1, _239, _240) (1, _188) (256, _235) (-1, _241) 0 ]", - "EXPR [ (-1, _240) (-1, _243) 128 ]", - "EXPR [ (-2, _233, _235) (1, _233) (1, _235) (-1, _244) 0 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _240) 0 ]], outputs: [_245]", - "EXPR [ (1, _240, _245) (1, _246) -1 ]", - "EXPR [ (1, _240, _246) 0 ]", - "EXPR [ (2, _243, _244) (1, _240) (-1, _247) 0 ]", - "EXPR [ (-1, _246) (-1, _248) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _241) 0 ]], outputs: [_249]", - "EXPR [ (1, _241, _249) (1, _250) -1 ]", - "EXPR [ (1, _241, _250) 0 ]", - "EXPR [ (-2, _235, _241) (256, _235) (1, _241) (-1, _251) 0 ]", - "EXPR [ (-1, _250) (-1, _252) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _185, _183) (1, _247, _248) (1, _183) (1, _185) 511 ], EXPR [ 256 ]], outputs: [_253, _254]", - "BLACKBOX::RANGE [(_253, 2)] []", - "BLACKBOX::RANGE [(_254, 8)] []", - "EXPR [ (-2, _183, _185) (1, _247, _248) (1, _183) (1, _185) (-256, _253) (-1, _254) 511 ]", - "EXPR [ (510, _183, _185) (-255, _183) (-255, _185) (-1, _255) 255 ]", - "EXPR [ (-1, _203, _254) (1, _203, _255) (1, _254) -32 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _1) 512 ], EXPR [ 256 ]], outputs: [_256, _257]", - "BLACKBOX::RANGE [(_256, 2)] []", - "BLACKBOX::RANGE [(_257, 8)] []", - "EXPR [ (-1, _1) (-256, _256) (-1, _257) 512 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 128 ], EXPR [ 256 ]], outputs: [_258, _259]", - "BLACKBOX::RANGE [(_258, 1)] []", - "BLACKBOX::RANGE [(_259, 8)] []", - "EXPR [ (1, _1) (-256, _258) (-1, _259) 128 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _257) 128 ], EXPR [ 256 ]], outputs: [_260, _261]", - "BLACKBOX::RANGE [(_260, 1)] []", - "BLACKBOX::RANGE [(_261, 8)] []", - "EXPR [ (1, _257) (-256, _260) (-1, _261) 128 ]", - "EXPR [ (-1, _258, _260) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (128, _257) 0 ], EXPR [ 256 ]], outputs: [_262, _263]", - "BLACKBOX::RANGE [(_262, 7)] []", - "BLACKBOX::RANGE [(_263, 8)] []", - "EXPR [ (128, _257) (-256, _262) (-1, _263) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _263) 0 ], EXPR [ 256 ]], outputs: [_264, _265]", - "BLACKBOX::RANGE [(_264, 1)] []", - "EXPR [ (1, _263) (-256, _264) (-1, _265) 0 ]", - "EXPR [ (1, _265) -128 ]", - "EXPR [ (-1, _35, _203) (1, _35) (-1, _266) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _257, _266) 0 ], EXPR [ 256 ]], outputs: [_267, _268]", - "BLACKBOX::RANGE [(_267, 246)] []", - "BLACKBOX::RANGE [(_268, 8)] []", - "EXPR [ (1, _257, _266) (-256, _267) (-1, _268) 0 ]", - "EXPR [ (-1, _267) (-1, _269) 85500948718122168836900022442411230814642048439125134155071110103811751936 ]", - "BLACKBOX::RANGE [(_269, 246)] []", - "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _267) 85500948718122168836900022442411230814642048439125134155071110103811751936 ]], outputs: [_270]", - "EXPR [ (-1, _267, _270) (85500948718122168836900022442411230814642048439125134155071110103811751936, _270) (1, _271) -1 ]", - "EXPR [ (-1, _267, _271) (85500948718122168836900022442411230814642048439125134155071110103811751936, _271) 0 ]", - "EXPR [ (1, _268, _271) (-1, _272) 0 ]", - "BLACKBOX::RANGE [(_272, 0)] []", - "EXPR [ (-1, _203) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _268) 0 ], EXPR [ 256 ]], outputs: [_273, _274]", + "BLACKBOX::RANGE [(_213, 7)] []", + "EXPR [ (1, _207) (-128, _212) (-1, _213) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _207) 504 ], EXPR [ 512 ]], outputs: [_214, _215]", + "BLACKBOX::RANGE [(_214, 1)] []", + "BLACKBOX::RANGE [(_215, 9)] []", + "EXPR [ (1, _207) (-512, _214) (-1, _215) 504 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _207) 0 ], EXPR [ 4 ], EXPR [ 2 ]], outputs: [[_216, _217, _218, _219]]", + "BLACKBOX::RANGE [(_216, 1)] []", + "BLACKBOX::RANGE [(_217, 1)] []", + "BLACKBOX::RANGE [(_218, 1)] []", + "BLACKBOX::RANGE [(_219, 1)] []", + "EXPR [ (1, _207) (-1, _216) (-2, _217) (-4, _218) (-8, _219) 0 ]", + "EXPR [ (1, _219, _219) (2, _219) (-1, _220) 1 ]", + "EXPR [ (-1, _218) (-1, _221) 1 ]", + "EXPR [ (2, _218, _220) (1, _220, _221) (-1, _222) 0 ]", + "EXPR [ (1, _222, _222) (-1, _223) 0 ]", + "EXPR [ (-1, _217) (-1, _224) 1 ]", + "EXPR [ (2, _217, _223) (1, _223, _224) (-1, _225) 0 ]", + "EXPR [ (1, _225, _225) (-1, _226) 0 ]", + "EXPR [ (-1, _216) (-1, _227) 1 ]", + "EXPR [ (2, _212, _214) (-1, _212) (-1, _214) (-1, _228) 1 ]", + "EXPR [ (2, _216, _226) (1, _226, _227) (-1, _229) 0 ]", + "EXPR [ (1, _228, _229) (-1, _230) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _197, _230) 0 ], EXPR [ 256 ]], outputs: [_231, _232]", + "BLACKBOX::RANGE [(_231, 246)] []", + "BLACKBOX::RANGE [(_232, 8)] []", + "EXPR [ (1, _197, _230) (-256, _231) (-1, _232) 0 ]", + "EXPR [ (-1, _231) (-1, _233) 85500948718122168836900022442411230814642048439125134155071110103811751936 ]", + "BLACKBOX::RANGE [(_233, 246)] []", + "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _231) 85500948718122168836900022442411230814642048439125134155071110103811751936 ]], outputs: [_234]", + "EXPR [ (-1, _231, _234) (85500948718122168836900022442411230814642048439125134155071110103811751936, _234) (1, _235) -1 ]", + "EXPR [ (-1, _231, _235) (85500948718122168836900022442411230814642048439125134155071110103811751936, _235) 0 ]", + "EXPR [ (1, _232, _235) (-1, _236) 0 ]", + "BLACKBOX::RANGE [(_236, 0)] []", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _232) 0 ], EXPR [ 256 ]], outputs: [_237, _238]", + "BLACKBOX::RANGE [(_237, 1)] []", + "EXPR [ (1, _232) (-256, _237) (-1, _238) 0 ]", + "EXPR [ (1, _238) -254 ]", + "EXPR [ (1, _0) (-1, _239) -1 ]", + "BLACKBOX::RANGE [(_239, 64)] []", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _239) 18446744073709551552 ], EXPR [ 18446744073709551616 ]], outputs: [_240, _241]", + "BLACKBOX::RANGE [(_241, 64)] []", + "EXPR [ (1, _239) (-18446744073709551616, _240) (-1, _241) 18446744073709551552 ]", + "EXPR [ (-1, _240) 0 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _239) 0 ], EXPR [ 7 ], EXPR [ 2 ]], outputs: [[_242, _243, _244, _245, _246, _247, _248]]", + "BLACKBOX::RANGE [(_242, 1)] []", + "BLACKBOX::RANGE [(_243, 1)] []", + "BLACKBOX::RANGE [(_244, 1)] []", + "BLACKBOX::RANGE [(_245, 1)] []", + "BLACKBOX::RANGE [(_246, 1)] []", + "BLACKBOX::RANGE [(_247, 1)] []", + "BLACKBOX::RANGE [(_248, 1)] []", + "EXPR [ (1, _239) (-1, _242) (-2, _243) (-4, _244) (-8, _245) (-16, _246) (-32, _247) (-64, _248) 0 ]", + "EXPR [ (1, _248, _248) (2, _248) (-1, _249) 1 ]", + "EXPR [ (-1, _247) (-1, _250) 1 ]", + "EXPR [ (2, _247, _249) (1, _249, _250) (-1, _251) 0 ]", + "EXPR [ (1, _251, _251) (-1, _252) 0 ]", + "EXPR [ (-1, _246) (-1, _253) 1 ]", + "EXPR [ (2, _246, _252) (1, _252, _253) (-1, _254) 0 ]", + "EXPR [ (1, _254, _254) (-1, _255) 0 ]", + "EXPR [ (-1, _245) (-1, _256) 1 ]", + "EXPR [ (2, _245, _255) (1, _255, _256) (-1, _257) 0 ]", + "EXPR [ (1, _257, _257) (-1, _258) 0 ]", + "EXPR [ (-1, _244) (-1, _259) 1 ]", + "EXPR [ (2, _244, _258) (1, _258, _259) (-1, _260) 0 ]", + "EXPR [ (1, _260, _260) (-1, _261) 0 ]", + "EXPR [ (-1, _243) (-1, _262) 1 ]", + "EXPR [ (2, _243, _261) (1, _261, _262) (-1, _263) 0 ]", + "EXPR [ (1, _263, _263) (-1, _264) 0 ]", + "EXPR [ (-1, _242) (-1, _265) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _264, _242) (1, _264, _265) 0 ]], outputs: [_266]", + "EXPR [ (2, _242, _264) (1, _264, _265) (-1, _267) 0 ]", + "EXPR [ (1, _266, _267) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _267) 0 ]], outputs: [_268, _269]", + "BLACKBOX::RANGE [(_269, 64)] []", + "EXPR [ (1, _267) (-1, _269) (-1, _270) -1 ]", + "BLACKBOX::RANGE [(_270, 64)] []", + "EXPR [ (-1, _267, _268) (1, _0) (-1, _269) 0 ]", + "EXPR [ (1, _268) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 32768 ]], outputs: [_271, _272]", + "BLACKBOX::RANGE [(_271, 1)] []", + "BLACKBOX::RANGE [(_272, 15)] []", + "EXPR [ (1, _2) (-32768, _271) (-1, _272) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 131072 ], EXPR [ 131072 ]], outputs: [_273, _274]", "BLACKBOX::RANGE [(_273, 1)] []", - "EXPR [ (1, _268) (-256, _273) (-1, _274) 0 ]", - "EXPR [ (1, _274) -254 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _89, _63) (1, _89, _90) 0 ]], outputs: [_275]", - "EXPR [ (-1, _276) (1, _364) (1, _365) 0 ]", - "EXPR [ (1, _275, _276) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _276) 0 ]], outputs: [_277, _278]", - "BLACKBOX::RANGE [(_277, 64)] []", - "BLACKBOX::RANGE [(_278, 64)] []", - "EXPR [ (1, _276) (-1, _278) (-1, _279) -1 ]", - "BLACKBOX::RANGE [(_279, 64)] []", - "EXPR [ (-1, _276, _277) (1, _0) (-1, _278) 0 ]", - "EXPR [ (-1, _61, _277) (1, _277) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _155) 0 ], EXPR [ 32768 ]], outputs: [_280, _281]", - "BLACKBOX::RANGE [(_280, 1)] []", - "BLACKBOX::RANGE [(_281, 15)] []", - "EXPR [ (1, _155) (-32768, _280) (-1, _281) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _155, _280) (1, _155) (65536, _280) 0 ], EXPR [ 8 ]], outputs: [_282, _283]", - "BLACKBOX::RANGE [(_282, 13)] []", - "BLACKBOX::RANGE [(_283, 3)] []", - "EXPR [ (-2, _155, _280) (1, _155) (65536, _280) (-8, _282) (-1, _283) 0 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _282) 0 ]], outputs: [_284]", - "EXPR [ (1, _282, _284) (1, _285) -1 ]", - "EXPR [ (1, _282, _285) 0 ]", - "EXPR [ (-2, _280, _282) (65536, _280) (1, _282) (-1, _286) 0 ]", - "EXPR [ (-1, _285) (-1, _287) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _283) 0 ]], outputs: [_288]", - "EXPR [ (1, _283, _288) (1, _289) -1 ]", - "EXPR [ (1, _283, _289) 0 ]", - "EXPR [ (-2, _280, _283) (65536, _280) (1, _283) (-1, _290) 0 ]", - "EXPR [ (-1, _289) (-1, _291) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _152, _150) (1, _286, _287) (1, _150) (1, _152) 131071 ], EXPR [ 65536 ]], outputs: [_292, _293]", - "BLACKBOX::RANGE [(_292, 2)] []", - "EXPR [ (-2, _150, _152) (1, _286, _287) (1, _150) (1, _152) (-65536, _292) (-1, _293) 131071 ]", - "EXPR [ (1, _293) -65439 ]", - "EXPR [ (1, _178) -65535 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _2) 131072 ], EXPR [ 65536 ]], outputs: [_294, _295]", - "BLACKBOX::RANGE [(_294, 2)] []", - "BLACKBOX::RANGE [(_295, 16)] []", - "EXPR [ (-1, _2) (-65536, _294) (-1, _295) 131072 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 32768 ], EXPR [ 65536 ]], outputs: [_296, _297]", - "BLACKBOX::RANGE [(_296, 1)] []", - "BLACKBOX::RANGE [(_297, 16)] []", - "EXPR [ (1, _2) (-65536, _296) (-1, _297) 32768 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _295) 32768 ], EXPR [ 65536 ]], outputs: [_298, _299]", - "BLACKBOX::RANGE [(_298, 1)] []", - "BLACKBOX::RANGE [(_299, 16)] []", - "EXPR [ (1, _295) (-65536, _298) (-1, _299) 32768 ]", - "EXPR [ (-1, _296, _298) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _295) 0 ], EXPR [ 32768 ]], outputs: [_300, _301]", - "BLACKBOX::RANGE [(_300, 1)] []", - "BLACKBOX::RANGE [(_301, 15)] []", - "EXPR [ (1, _295) (-32768, _300) (-1, _301) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _295) 131072 ], EXPR [ 131072 ]], outputs: [_302, _303]", - "BLACKBOX::RANGE [(_302, 1)] []", - "BLACKBOX::RANGE [(_303, 17)] []", - "EXPR [ (1, _295) (-131072, _302) (-1, _303) 131072 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _302, _300) (1, _295) (-1, _300) (-1, _302) 1 ], EXPR [ 65536 ]], outputs: [_304, _305]", - "BLACKBOX::RANGE [(_304, 1)] []", - "BLACKBOX::RANGE [(_305, 16)] []", - "EXPR [ (2, _300, _302) (1, _295) (-1, _300) (-1, _302) (-65536, _304) (-1, _305) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _148, _122) (1, _148, _149) 0 ], EXPR [ 32768 ]], outputs: [_306, _307]", - "BLACKBOX::RANGE [(_306, 1)] []", - "BLACKBOX::RANGE [(_307, 15)] []", - "EXPR [ (-32768, _306) (-1, _307) (1, _389) (1, _390) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _305) 0 ], EXPR [ 32768 ]], outputs: [_308, _309]", - "BLACKBOX::RANGE [(_308, 1)] []", - "BLACKBOX::RANGE [(_309, 15)] []", - "EXPR [ (1, _305) (-32768, _308) (-1, _309) 0 ]", - "EXPR [ (-1, _310) (-1, _389) (-1, _390) 32768 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _148, _122) (1, _148, _149) (2, _310, _306) 0 ]], outputs: [_311]", - "EXPR [ (2, _306, _310) (-1, _312) (1, _389) (1, _390) 0 ]", - "EXPR [ (1, _311, _312) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _305, _308) (1, _305) (65536, _308) 0 ], EXPR [ (1, _312) 0 ]], outputs: [_313, _314]", + "BLACKBOX::RANGE [(_274, 17)] []", + "EXPR [ (1, _2) (-131072, _273) (-1, _274) 131072 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _273, _271) (1, _2) (-1, _271) (-1, _273) 1 ], EXPR [ 65536 ]], outputs: [_275, _276]", + "BLACKBOX::RANGE [(_275, 1)] []", + "BLACKBOX::RANGE [(_276, 16)] []", + "EXPR [ (2, _271, _273) (1, _2) (-1, _271) (-1, _273) (-65536, _275) (-1, _276) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _276) 0 ], EXPR [ 32768 ]], outputs: [_277, _278]", + "BLACKBOX::RANGE [(_277, 1)] []", + "BLACKBOX::RANGE [(_278, 15)] []", + "EXPR [ (1, _276) (-32768, _277) (-1, _278) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _276, _277) (1, _276) (65536, _277) 0 ], EXPR [ 8 ]], outputs: [_279, _280]", + "BLACKBOX::RANGE [(_279, 13)] []", + "BLACKBOX::RANGE [(_280, 3)] []", + "EXPR [ (-2, _276, _277) (1, _276) (65536, _277) (-8, _279) (-1, _280) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _279) 0 ]], outputs: [_281]", + "EXPR [ (1, _279, _281) (1, _282) -1 ]", + "EXPR [ (1, _279, _282) 0 ]", + "EXPR [ (-2, _277, _279) (65536, _277) (1, _279) (-1, _283) 0 ]", + "EXPR [ (-1, _282) (-1, _284) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _280) 0 ]], outputs: [_285]", + "EXPR [ (1, _280, _285) (1, _286) -1 ]", + "EXPR [ (1, _280, _286) 0 ]", + "EXPR [ (-2, _277, _280) (65536, _277) (1, _280) (-1, _287) 0 ]", + "EXPR [ (-1, _286) (-1, _288) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _273, _271) (1, _283, _284) (1, _271) (1, _273) 131071 ], EXPR [ 65536 ]], outputs: [_289, _290]", + "BLACKBOX::RANGE [(_289, 2)] []", + "EXPR [ (-2, _271, _273) (1, _283, _284) (1, _271) (1, _273) (-65536, _289) (-1, _290) 131071 ]", + "EXPR [ (1, _290) -65439 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _276) 0 ], EXPR [ 32768 ]], outputs: [_291, _292]", + "BLACKBOX::RANGE [(_291, 1)] []", + "BLACKBOX::RANGE [(_292, 15)] []", + "EXPR [ (1, _276) (-32768, _291) (-1, _292) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _276, _291) (1, _276) (65536, _291) 0 ], EXPR [ 16384 ]], outputs: [_293, _294]", + "BLACKBOX::RANGE [(_293, 2)] []", + "BLACKBOX::RANGE [(_294, 14)] []", + "EXPR [ (-2, _276, _291) (1, _276) (65536, _291) (-16384, _293) (-1, _294) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _293) 0 ]], outputs: [_295]", + "EXPR [ (1, _293, _295) (1, _296) -1 ]", + "EXPR [ (1, _293, _296) 0 ]", + "EXPR [ (-2, _291, _293) (65536, _291) (1, _293) (-1, _297) 0 ]", + "EXPR [ (-1, _296) (-1, _298) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _294) 0 ]], outputs: [_299]", + "EXPR [ (1, _294, _299) (1, _300) -1 ]", + "EXPR [ (1, _294, _300) 0 ]", + "EXPR [ (-2, _291, _294) (65536, _291) (1, _294) (-1, _301) 0 ]", + "EXPR [ (-1, _300) (-1, _302) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _273, _271) (1, _297, _298) (1, _271) (1, _273) 131071 ], EXPR [ 65536 ]], outputs: [_303, _304]", + "BLACKBOX::RANGE [(_303, 2)] []", + "EXPR [ (-2, _271, _273) (1, _297, _298) (1, _271) (1, _273) (-65536, _303) (-1, _304) 131071 ]", + "EXPR [ (1, _304) -65535 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 65536 ]], outputs: [_305, _306]", + "BLACKBOX::RANGE [(_305, 48)] []", + "BLACKBOX::RANGE [(_306, 16)] []", + "EXPR [ (1, _0) (-65536, _305) (-1, _306) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _306) 0 ], EXPR [ 32768 ]], outputs: [_307, _308]", + "BLACKBOX::RANGE [(_307, 1)] []", + "BLACKBOX::RANGE [(_308, 15)] []", + "EXPR [ (1, _306) (-32768, _307) (-1, _308) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _306) 131086 ], EXPR [ 131072 ]], outputs: [_309, _310]", + "BLACKBOX::RANGE [(_309, 1)] []", + "BLACKBOX::RANGE [(_310, 17)] []", + "EXPR [ (-1, _306) (-131072, _309) (-1, _310) 131086 ]", + "EXPR [ (-2, _307, _309) (1, _307) (1, _309) (-1, _311) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (28, _309, _307) (1, _311, _306) (-14, _307) (-14, _309) 65535 ], EXPR [ 65536 ]], outputs: [_312, _313]", "BLACKBOX::RANGE [(_313, 16)] []", - "BLACKBOX::RANGE [(_314, 16)] []", - "EXPR [ (1, _312) (-1, _314) (-1, _315) -1 ]", - "BLACKBOX::RANGE [(_315, 16)] []", - "EXPR [ (-2, _305, _308) (-1, _312, _313) (1, _305) (65536, _308) (-1, _314) 0 ]", - "EXPR [ (-1, _313) (-1, _316) 32768 ]", - "EXPR [ (-2, _306, _308) (1, _306) (1, _308) (-1, _317) 0 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _313) 0 ]], outputs: [_318]", - "EXPR [ (1, _313, _318) (1, _319) -1 ]", - "EXPR [ (1, _313, _319) 0 ]", - "EXPR [ (2, _316, _317) (1, _313) (-1, _320) 0 ]", - "EXPR [ (-1, _319) (-1, _321) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _314) 0 ]], outputs: [_322]", - "EXPR [ (1, _314, _322) (1, _323) -1 ]", - "EXPR [ (1, _314, _323) 0 ]", - "EXPR [ (-2, _308, _314) (65536, _308) (1, _314) (-1, _324) 0 ]", - "EXPR [ (-1, _323) (-1, _325) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _302, _300) (1, _320, _321) (1, _300) (1, _302) 131071 ], EXPR [ 65536 ]], outputs: [_326, _327]", - "BLACKBOX::RANGE [(_326, 2)] []", - "BLACKBOX::RANGE [(_327, 16)] []", - "EXPR [ (-2, _300, _302) (1, _320, _321) (1, _300) (1, _302) (-65536, _326) (-1, _327) 131071 ]", - "EXPR [ (131070, _300, _302) (-65535, _300) (-65535, _302) (-1, _328) 65535 ]", - "EXPR [ (-1, _120, _327) (1, _120, _328) (1, _327) 0 ]", + "EXPR [ (1, _306, _311) (28, _307, _309) (-14, _307) (-14, _309) (-65536, _312) (-1, _313) 65535 ]", + "EXPR [ (-1, _312) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (28, _309, _307) (1, _311, _306) (-14, _307) (-14, _309) 14 ], EXPR [ 32768 ]], outputs: [_314, _315]", + "BLACKBOX::RANGE [(_314, 1)] []", + "BLACKBOX::RANGE [(_315, 15)] []", + "EXPR [ (1, _306, _311) (28, _307, _309) (-14, _307) (-14, _309) (-32768, _314) (-1, _315) 14 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (28, _309, _307) (1, _311, _306) (-14, _307) (-14, _309) 131070 ], EXPR [ 131072 ]], outputs: [_316, _317]", + "BLACKBOX::RANGE [(_316, 1)] []", + "BLACKBOX::RANGE [(_317, 17)] []", + "EXPR [ (1, _306, _311) (28, _307, _309) (-14, _307) (-14, _309) (-131072, _316) (-1, _317) 131070 ]", + "EXPR [ (2, _314, _316) (-1, _314) (-1, _316) (-1, _318) 1 ]", + "EXPR [ (1, _306, _311) (28, _307, _309) (-14, _307) (-14, _309) (-1, _319) 14 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _318, _319) 0 ], EXPR [ 5 ], EXPR [ 2 ]], outputs: [[_320, _321, _322, _323, _324]]", + "BLACKBOX::RANGE [(_320, 1)] []", + "BLACKBOX::RANGE [(_321, 1)] []", + "BLACKBOX::RANGE [(_322, 1)] []", + "BLACKBOX::RANGE [(_323, 1)] []", + "BLACKBOX::RANGE [(_324, 1)] []", + "EXPR [ (1, _318, _319) (-1, _320) (-2, _321) (-4, _322) (-8, _323) (-16, _324) 0 ]", + "EXPR [ (1, _324, _324) (2, _324) (-1, _325) 1 ]", + "EXPR [ (-1, _323) (-1, _326) 1 ]", + "EXPR [ (2, _323, _325) (1, _325, _326) (-1, _327) 0 ]", + "EXPR [ (1, _327, _327) (-1, _328) 0 ]", + "EXPR [ (-1, _322) (-1, _329) 1 ]", + "EXPR [ (2, _322, _328) (1, _328, _329) (-1, _330) 0 ]", + "EXPR [ (1, _330, _330) (-1, _331) 0 ]", + "EXPR [ (-1, _321) (-1, _332) 1 ]", + "EXPR [ (2, _321, _331) (1, _331, _332) (-1, _333) 0 ]", + "EXPR [ (1, _333, _333) (-1, _334) 0 ]", + "EXPR [ (-1, _320) (-1, _335) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _334, _320) (1, _334, _335) 0 ], EXPR [ 32768 ]], outputs: [_336, _337]", + "BLACKBOX::RANGE [(_336, 1)] []", + "BLACKBOX::RANGE [(_337, 15)] []", + "EXPR [ (2, _320, _334) (-1, _488) 0 ]", + "EXPR [ (1, _334, _335) (-1, _489) 0 ]", + "EXPR [ (-32768, _336) (-1, _337) (1, _488) (1, _489) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _276) 0 ], EXPR [ 32768 ]], outputs: [_338, _339]", + "BLACKBOX::RANGE [(_338, 1)] []", + "BLACKBOX::RANGE [(_339, 15)] []", + "EXPR [ (1, _276) (-32768, _338) (-1, _339) 0 ]", + "EXPR [ (-1, _340) (-1, _488) (-1, _489) 32768 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _334, _320) (1, _334, _335) (2, _340, _336) 0 ]], outputs: [_341]", + "EXPR [ (2, _336, _340) (-1, _342) (1, _488) (1, _489) 0 ]", + "EXPR [ (1, _341, _342) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _276, _338) (1, _276) (65536, _338) 0 ], EXPR [ (1, _342) 0 ]], outputs: [_343, _344]", + "BLACKBOX::RANGE [(_343, 16)] []", + "BLACKBOX::RANGE [(_344, 16)] []", + "EXPR [ (1, _342) (-1, _344) (-1, _345) -1 ]", + "BLACKBOX::RANGE [(_345, 16)] []", + "EXPR [ (-2, _276, _338) (-1, _342, _343) (1, _276) (65536, _338) (-1, _344) 0 ]", + "EXPR [ (-1, _343) (-1, _346) 32768 ]", + "EXPR [ (-2, _336, _338) (1, _336) (1, _338) (-1, _347) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _343) 0 ]], outputs: [_348]", + "EXPR [ (1, _343, _348) (1, _349) -1 ]", + "EXPR [ (1, _343, _349) 0 ]", + "EXPR [ (2, _346, _347) (1, _343) (-1, _350) 0 ]", + "EXPR [ (-1, _349) (-1, _351) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _344) 0 ]], outputs: [_352]", + "EXPR [ (1, _344, _352) (1, _353) -1 ]", + "EXPR [ (1, _344, _353) 0 ]", + "EXPR [ (-2, _338, _344) (65536, _338) (1, _344) (-1, _354) 0 ]", + "EXPR [ (-1, _353) (-1, _355) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _273, _271) (1, _350, _351) (1, _271) (1, _273) 131071 ], EXPR [ 65536 ]], outputs: [_356, _357]", + "BLACKBOX::RANGE [(_356, 2)] []", + "BLACKBOX::RANGE [(_357, 16)] []", + "EXPR [ (-2, _271, _273) (1, _350, _351) (1, _271) (1, _273) (-65536, _356) (-1, _357) 131071 ]", + "EXPR [ (131070, _271, _273) (-65535, _271) (-65535, _273) (-1, _358) 65535 ]", + "EXPR [ (-1, _318) (-1, _359) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _318, _357) (1, _358, _359) 0 ], EXPR [ 65536 ]], outputs: [_360, _361]", + "BLACKBOX::RANGE [(_360, 1)] []", + "EXPR [ (1, _318, _357) (1, _358, _359) (-65536, _360) (-1, _361) 0 ]", + "EXPR [ (1, _361) -65535 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _2) 131072 ], EXPR [ 65536 ]], outputs: [_362, _363]", + "BLACKBOX::RANGE [(_362, 2)] []", + "BLACKBOX::RANGE [(_363, 16)] []", + "EXPR [ (-1, _2) (-65536, _362) (-1, _363) 131072 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 32768 ], EXPR [ 65536 ]], outputs: [_364, _365]", + "BLACKBOX::RANGE [(_364, 1)] []", + "BLACKBOX::RANGE [(_365, 16)] []", + "EXPR [ (1, _2) (-65536, _364) (-1, _365) 32768 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _363) 32768 ], EXPR [ 65536 ]], outputs: [_366, _367]", + "BLACKBOX::RANGE [(_366, 1)] []", + "BLACKBOX::RANGE [(_367, 16)] []", + "EXPR [ (1, _363) (-65536, _366) (-1, _367) 32768 ]", + "EXPR [ (-1, _364, _366) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _363) 0 ], EXPR [ 32768 ]], outputs: [_368, _369]", + "BLACKBOX::RANGE [(_368, 1)] []", + "BLACKBOX::RANGE [(_369, 15)] []", + "EXPR [ (1, _363) (-32768, _368) (-1, _369) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _363) 131072 ], EXPR [ 131072 ]], outputs: [_370, _371]", + "BLACKBOX::RANGE [(_370, 1)] []", + "BLACKBOX::RANGE [(_371, 17)] []", + "EXPR [ (1, _363) (-131072, _370) (-1, _371) 131072 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _370, _368) (1, _363) (-1, _368) (-1, _370) 1 ], EXPR [ 65536 ]], outputs: [_372, _373]", + "BLACKBOX::RANGE [(_372, 1)] []", + "BLACKBOX::RANGE [(_373, 16)] []", + "EXPR [ (2, _368, _370) (1, _363) (-1, _368) (-1, _370) (-65536, _372) (-1, _373) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _334, _320) (1, _334, _335) 0 ], EXPR [ 32768 ]], outputs: [_374, _375]", + "BLACKBOX::RANGE [(_374, 1)] []", + "BLACKBOX::RANGE [(_375, 15)] []", + "EXPR [ (-32768, _374) (-1, _375) (1, _488) (1, _489) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _373) 0 ], EXPR [ 32768 ]], outputs: [_376, _377]", + "BLACKBOX::RANGE [(_376, 1)] []", + "BLACKBOX::RANGE [(_377, 15)] []", + "EXPR [ (1, _373) (-32768, _376) (-1, _377) 0 ]", + "EXPR [ (-1, _378) (-1, _488) (-1, _489) 32768 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _334, _320) (1, _334, _335) (2, _378, _374) 0 ]], outputs: [_379]", + "EXPR [ (2, _374, _378) (-1, _380) (1, _488) (1, _489) 0 ]", + "EXPR [ (1, _379, _380) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _373, _376) (1, _373) (65536, _376) 0 ], EXPR [ (1, _380) 0 ]], outputs: [_381, _382]", + "BLACKBOX::RANGE [(_381, 16)] []", + "BLACKBOX::RANGE [(_382, 16)] []", + "EXPR [ (1, _380) (-1, _382) (-1, _383) -1 ]", + "BLACKBOX::RANGE [(_383, 16)] []", + "EXPR [ (-2, _373, _376) (-1, _380, _381) (1, _373) (65536, _376) (-1, _382) 0 ]", + "EXPR [ (-1, _381) (-1, _384) 32768 ]", + "EXPR [ (-2, _374, _376) (1, _374) (1, _376) (-1, _385) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _381) 0 ]], outputs: [_386]", + "EXPR [ (1, _381, _386) (1, _387) -1 ]", + "EXPR [ (1, _381, _387) 0 ]", + "EXPR [ (2, _384, _385) (1, _381) (-1, _388) 0 ]", + "EXPR [ (-1, _387) (-1, _389) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _382) 0 ]], outputs: [_390]", + "EXPR [ (1, _382, _390) (1, _391) -1 ]", + "EXPR [ (1, _382, _391) 0 ]", + "EXPR [ (-2, _376, _382) (65536, _376) (1, _382) (-1, _392) 0 ]", + "EXPR [ (-1, _391) (-1, _393) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _370, _368) (1, _388, _389) (1, _368) (1, _370) 131071 ], EXPR [ 65536 ]], outputs: [_394, _395]", + "BLACKBOX::RANGE [(_394, 2)] []", + "BLACKBOX::RANGE [(_395, 16)] []", + "EXPR [ (-2, _368, _370) (1, _388, _389) (1, _368) (1, _370) (-65536, _394) (-1, _395) 131071 ]", + "EXPR [ (131070, _368, _370) (-65535, _368) (-65535, _370) (-1, _396) 65535 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _318, _395) (1, _396, _359) 0 ], EXPR [ 65536 ]], outputs: [_397, _398]", + "BLACKBOX::RANGE [(_397, 1)] []", + "EXPR [ (1, _318, _395) (1, _359, _396) (-65536, _397) (-1, _398) 0 ]", + "EXPR [ (1, _398) 0 ]", "unconstrained func 0", "[Const { destination: Direct(10), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(11), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(10), offset_address: Direct(11) }, BinaryFieldOp { destination: Direct(2), op: IntegerDiv, lhs: Direct(0), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Mul, lhs: Direct(2), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Sub, lhs: Direct(0), rhs: Direct(1) }, Mov { destination: Direct(0), source: Direct(2) }, Stop { return_data: HeapVector { pointer: Direct(11), size: Direct(10) } }]", "unconstrained func 1", @@ -574,10 +707,10 @@ expression: artifact "unconstrained func 2", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "pdnLThtJFIDhd/GaRZ9b1al5ldEocogTIVmAHIg0ivLu09Wn/1wWs2lvfH5wzhcwLmPs76dPl4/vXz48PX9++Xr66+/vp4+3p+v16cuH68vj+e3p5Xn97PcfDyc+/PB2u1zWT51+u37dej3fLs9vp7+e36/Xh9O38/V9+0dfX8/P23w739Zrl4fT5fnTOlfw89P1MuvHw6/t5f9XZbF9WeTXehza70f2Tdi3vG/f/cj+yH1flzv3RQ7sqwb7du/+kdvf1Pd9O/T/m+TPfb1z/8jP30LZb+2+/X7k63fj9nM/cvt54/x4P3L+PH/u57hvfxy5/4Rw/kLu3Fc7sm+dfb93/8jtF40H32hH7j/ROb+Rcuf+ka+//Xz8bsud+xJH9o3brx16/P59/9DX3/j5t2537h95/GqD268vRx6/uvL9d9X79s3u3P/z+/9n/ej8+HT74xnPyddfmQ+n2C7bdtm3y9wux3YpSw2poTWsRgFSghQhZUghUoqWoqVoKVqKlqKlaClaipaipVgpVoqVYqVYKVaKlWKlWClWipfipXgpXoqX4qV4KV6Kl+KlRCmxKusvrViV9b4TVsNrRI1Wo9fIGquy/rJqq7I+ZjSpoTWshteIGq1Gr5E1xjZ6Kb2UXkovpZfSV6WtY1XWM9J7jawxtpFLDamhNVZlfVKQqzLWETVajV5j3i7rHS9HzbHsU/ap+7R9+j5jn22ffZ+7N3ZPloUQQgkjnAiiEZ1IAlmQBVmQBVmQBVmQBVmQBVmRFVmRFVmRFVmRFVmRFdmQDdmQDdmQDdmQDdmQDdmRHdmRHdmRHdmRHdmRHTmQAzmQAzmQAzmQAzmQA7khN+SG3JAbckNuyA25ITfkjjyPlWwPbFPWGUY4EUQjOpHE2GMetAohkBM5kRM5kRM5kRN5IA/kgTyQB/JAHsgDeSCPXdZlIYRQwggngmhEJ5JAFmRBFmRBFmRBFmRBFmRBVmRFVmRFVmRFVmRFVmRFNmRDNmRDNmRDNmRDNmRDdmRHdmRHdmRHdmRHdmRHDuRADuRADuTtDNqMKbcZnUhi7LGdwS2EUGLKfcaUc0YQjehEEmOP7QxuIYQSRiB35I7ckTtyR07kRE7kRE7kRE7kRE7kRB7IA3kgD+SBPJAH8nYGx4ycL4PMGBU2z2CFEEoY4UQQjehEEsiCLMiCLMiCLMiCLMiCLMiKrMiKrMiKrMiKrMiKrMiGbMiGbMiGbMiGbMiGbMiO7MiO7MiO7MiO7MiO7MiBHMiBHMiBHMiBHMiBHMgNuSE35IbckBtyQ27I8wzq9gR6yjqfQi+EEEoY4UQQjehEEsiJnMjzDKrNMMKJIBrRiSSm7POJ/pRjhhBKGOFEEI3oRBKjwpeFEEIJI5wIYsptxpT7jCTGHtsZ3EIIJYxwIogp54wpjxlJjD22M7iFEEoY4UQQjUBWZEU2ZEM2ZEM2ZEM2ZEOeZ3C+duDzDNr2d9gyXw6dIYQSRjgRRCM6kcTYI5ADOZC3P99shhNBNKITSYw95hmsEEIJ5IbckBtyQ27IDbkjd+SO3JE7ckfuyB25I3fkRE7kRE7kRE7kRE7kRE7kgTyQB/JAHsgDeSAP5IE8djnmGbT5+tS38+3p/PF6+Vpv33x+f3787d2ct39fuYb3e15vL4+XT++3y3wdZLtufWXkPw==", + "debug_symbols": "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", "file_map": { "50": { - "source": "fn main(x: u64, y: u8, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176, superseded by issue #8791\n assert(u >> (x as u8) == -1);\n assert(z >> (x as u8) == -1);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n\n assert(z >> 16 == -1);\n assert(-z >> x as u8 == 0);\n}\n", + "source": "fn main(x: u64, y: u64, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176, superseded by issue #8791\n assert(u >> (x as i64 - 2) == -1);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> a == 32);\n a = -a;\n assert(a << 6 == -64);\n assert(a << -a == -2);\n\n assert(x >> (x - 1) == 0);\n\n assert_eq(z >> 3, -97);\n\n assert(z >> 14 == -1);\n let rhs = (if x as i16 > 14 { 14 } else { x as i16 });\n assert(z >> rhs == -1);\n assert(-z >> rhs == 0);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 1767192b8eb..7755aac6b8a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -21,7 +21,7 @@ expression: artifact "type": { "kind": "integer", "sign": "unsigned", - "width": 8 + "width": 64 }, "visibility": "private" }, @@ -50,31 +50,39 @@ expression: artifact "error_kind": "string", "string": "attempt to subtract with overflow" }, - "5795655218219125583": { + "6668324276689745315": { + "error_kind": "string", + "string": "Field failed to decompose into specified 4 limbs" + }, + "13958753312450585022": { "error_kind": "string", - "string": "Field failed to decompose into specified 8 limbs" + "string": "Field failed to decompose into specified 7 limbs" }, "14514982005979867414": { "error_kind": "string", "string": "attempt to bit-shift with overflow" + }, + "16061458491050355795": { + "error_kind": "string", + "string": "Field failed to decompose into specified 5 limbs" } } }, "bytecode": [ "func 0", - "current witness index : _416", + "current witness index : _489", "private parameters indices : [_0, _1, _2, _3]", "public parameters indices : []", "return value indices : []", "BLACKBOX::RANGE [(_0, 64)] []", - "BLACKBOX::RANGE [(_1, 8)] []", + "BLACKBOX::RANGE [(_1, 64)] []", "BLACKBOX::RANGE [(_2, 16)] []", "BLACKBOX::RANGE [(_3, 64)] []", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 224 ], EXPR [ 256 ]], outputs: [_4, _5]", - "BLACKBOX::RANGE [(_4, 1)] []", - "BLACKBOX::RANGE [(_5, 8)] []", - "EXPR [ (1, _1) (-256, _4) (-1, _5) 224 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_6, _7, _8, _9, _10, _11, _12, _13]]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 18446744073709551552 ], EXPR [ 18446744073709551616 ]], outputs: [_4, _5]", + "BLACKBOX::RANGE [(_5, 64)] []", + "EXPR [ (1, _1) (-18446744073709551616, _4) (-1, _5) 18446744073709551552 ]", + "EXPR [ (-1, _4) 0 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _1) 0 ], EXPR [ 7 ], EXPR [ 2 ]], outputs: [[_6, _7, _8, _9, _10, _11, _12]]", "BLACKBOX::RANGE [(_6, 1)] []", "BLACKBOX::RANGE [(_7, 1)] []", "BLACKBOX::RANGE [(_8, 1)] []", @@ -82,112 +90,121 @@ expression: artifact "BLACKBOX::RANGE [(_10, 1)] []", "BLACKBOX::RANGE [(_11, 1)] []", "BLACKBOX::RANGE [(_12, 1)] []", - "BLACKBOX::RANGE [(_13, 1)] []", - "EXPR [ (1, _1) (-1, _6) (-2, _7) (-4, _8) (-8, _9) (-16, _10) (-32, _11) (-64, _12) (-128, _13) 0 ]", - "EXPR [ (1, _13, _13) (2, _13) (-1, _14) 1 ]", - "EXPR [ (-1, _12) (-1, _15) 1 ]", - "EXPR [ (2, _12, _14) (1, _14, _15) (-1, _16) 0 ]", - "EXPR [ (1, _16, _16) (-1, _17) 0 ]", - "EXPR [ (-1, _11) (-1, _18) 1 ]", - "EXPR [ (2, _11, _17) (1, _17, _18) (-1, _19) 0 ]", - "EXPR [ (1, _19, _19) (-1, _20) 0 ]", - "EXPR [ (-1, _10) (-1, _21) 1 ]", - "EXPR [ (2, _10, _20) (1, _20, _21) (-1, _22) 0 ]", - "EXPR [ (1, _22, _22) (-1, _23) 0 ]", - "EXPR [ (-1, _9) (-1, _24) 1 ]", - "EXPR [ (2, _9, _23) (1, _23, _24) (-1, _25) 0 ]", - "EXPR [ (1, _25, _25) (-1, _26) 0 ]", - "EXPR [ (-1, _8) (-1, _27) 1 ]", - "EXPR [ (2, _8, _26) (1, _26, _27) (-1, _28) 0 ]", - "EXPR [ (1, _28, _28) (-1, _29) 0 ]", - "EXPR [ (-1, _7) (-1, _30) 1 ]", - "EXPR [ (2, _7, _29) (1, _29, _30) (-1, _31) 0 ]", - "EXPR [ (1, _31, _31) (-1, _32) 0 ]", - "EXPR [ (-1, _6) (-1, _33) 1 ]", - "EXPR [ (-1, _4) (-1, _34) 1 ]", - "EXPR [ (2, _6, _32) (1, _32, _33) (-1, _35) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (64, _34, _35) 0 ], EXPR [ 4294967296 ]], outputs: [_36, _37]", - "BLACKBOX::RANGE [(_36, 222)] []", - "EXPR [ (64, _34, _35) (-4294967296, _36) (-1, _37) 0 ]", - "EXPR [ (-1, _36) (-1, _38) 5096253676302562286669017222071363378443840053029366383258766538131 ]", - "BLACKBOX::RANGE [(_38, 222)] []", - "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _36) 5096253676302562286669017222071363378443840053029366383258766538131 ]], outputs: [_39]", - "EXPR [ (-1, _36, _39) (5096253676302562286669017222071363378443840053029366383258766538131, _39) (1, _40) -1 ]", - "EXPR [ (-1, _36, _40) (5096253676302562286669017222071363378443840053029366383258766538131, _40) 0 ]", - "EXPR [ (1, _37, _40) (268435455, _40) (-1, _41) 0 ]", - "BLACKBOX::RANGE [(_41, 32)] []", - "EXPR [ (1, _34) -1 ]", - "EXPR [ (1, _37) -128 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _35) 0 ]], outputs: [_42]", - "EXPR [ (1, _35, _42) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ 64 ], EXPR [ (1, _35) 0 ]], outputs: [_43, _44]", - "BLACKBOX::RANGE [(_44, 32)] []", - "EXPR [ (1, _35) (-1, _44) (-1, _45) -1 ]", - "BLACKBOX::RANGE [(_45, 32)] []", - "EXPR [ (-1, _35, _43) (-1, _44) 64 ]", - "EXPR [ (1, _43) -32 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 192 ], EXPR [ 256 ]], outputs: [_46, _47]", - "BLACKBOX::RANGE [(_47, 8)] []", - "EXPR [ (1, _1) (-256, _46) (-1, _47) 192 ]", - "EXPR [ (-1, _35, _46) (1, _35) (-1, _48) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0, _48) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_49, _50]", - "BLACKBOX::RANGE [(_49, 190)] []", - "EXPR [ (1, _0, _48) (-18446744073709551616, _49) (-1, _50) 0 ]", - "EXPR [ (-1, _49) (-1, _51) 1186564023676924939888766319973246049704924238154051448977 ]", - "BLACKBOX::RANGE [(_51, 190)] []", - "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _49) 1186564023676924939888766319973246049704924238154051448977 ]], outputs: [_52]", - "EXPR [ (-1, _49, _52) (1186564023676924939888766319973246049704924238154051448977, _52) (1, _53) -1 ]", - "EXPR [ (-1, _49, _53) (1186564023676924939888766319973246049704924238154051448977, _53) 0 ]", - "EXPR [ (1, _50, _53) (4331911350818177023, _53) (-1, _54) 0 ]", - "BLACKBOX::RANGE [(_54, 63)] []", - "EXPR [ (-1, _46) 0 ]", - "EXPR [ (1, _50) -128 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _35) 0 ]], outputs: [_55]", - "EXPR [ (1, _35, _55) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _35) 0 ]], outputs: [_56, _57]", - "BLACKBOX::RANGE [(_57, 64)] []", - "EXPR [ (1, _35) (-1, _57) (-1, _58) -1 ]", - "BLACKBOX::RANGE [(_58, 64)] []", - "EXPR [ (-1, _35, _56) (1, _0) (-1, _57) 0 ]", - "EXPR [ (1, _56) -32 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 256 ]], outputs: [_59, _60]", - "BLACKBOX::RANGE [(_59, 56)] []", - "BLACKBOX::RANGE [(_60, 8)] []", - "EXPR [ (1, _0) (-256, _59) (-1, _60) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _60) 192 ], EXPR [ 256 ]], outputs: [_61, _62]", - "BLACKBOX::RANGE [(_61, 1)] []", - "BLACKBOX::RANGE [(_62, 8)] []", - "EXPR [ (1, _60) (-256, _61) (-1, _62) 192 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _61, _60) (1, _60) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_63, _64, _65, _66, _67, _68, _69, _70]]", - "BLACKBOX::RANGE [(_63, 1)] []", + "EXPR [ (1, _1) (-1, _6) (-2, _7) (-4, _8) (-8, _9) (-16, _10) (-32, _11) (-64, _12) 0 ]", + "EXPR [ (1, _12, _12) (2, _12) (-1, _13) 1 ]", + "EXPR [ (-1, _11) (-1, _14) 1 ]", + "EXPR [ (2, _11, _13) (1, _13, _14) (-1, _15) 0 ]", + "EXPR [ (1, _15, _15) (-1, _16) 0 ]", + "EXPR [ (-1, _10) (-1, _17) 1 ]", + "EXPR [ (2, _10, _16) (1, _16, _17) (-1, _18) 0 ]", + "EXPR [ (1, _18, _18) (-1, _19) 0 ]", + "EXPR [ (-1, _9) (-1, _20) 1 ]", + "EXPR [ (2, _9, _19) (1, _19, _20) (-1, _21) 0 ]", + "EXPR [ (1, _21, _21) (-1, _22) 0 ]", + "EXPR [ (-1, _8) (-1, _23) 1 ]", + "EXPR [ (2, _8, _22) (1, _22, _23) (-1, _24) 0 ]", + "EXPR [ (1, _24, _24) (-1, _25) 0 ]", + "EXPR [ (-1, _7) (-1, _26) 1 ]", + "EXPR [ (2, _7, _25) (1, _25, _26) (-1, _27) 0 ]", + "EXPR [ (1, _27, _27) (-1, _28) 0 ]", + "EXPR [ (-1, _6) (-1, _29) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (128, _28, _6) (64, _28, _29) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_30, _31]", + "BLACKBOX::RANGE [(_30, 190)] []", + "EXPR [ (128, _6, _28) (-1, _411) 0 ]", + "EXPR [ (64, _28, _29) (-1, _412) 0 ]", + "EXPR [ (-18446744073709551616, _30) (-1, _31) (1, _411) (1, _412) 0 ]", + "EXPR [ (-1, _30) (-1, _32) 1186564023676924939888766319973246049704924238154051448977 ]", + "BLACKBOX::RANGE [(_32, 190)] []", + "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _30) 1186564023676924939888766319973246049704924238154051448977 ]], outputs: [_33]", + "EXPR [ (-1, _30, _33) (1186564023676924939888766319973246049704924238154051448977, _33) (1, _34) -1 ]", + "EXPR [ (-1, _30, _34) (1186564023676924939888766319973246049704924238154051448977, _34) 0 ]", + "EXPR [ (1, _31, _34) (4331911350818177023, _34) (-1, _35) 0 ]", + "BLACKBOX::RANGE [(_35, 63)] []", + "EXPR [ (1, _31) -128 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _28, _6) (1, _28, _29) 0 ]], outputs: [_36]", + "EXPR [ (-1, _37) (-342003794872488675347600089769644923258568193756500536620284440415247007744, _411) (-342003794872488675347600089769644923258568193756500536620284440415247007744, _412) 0 ]", + "EXPR [ (1, _36, _37) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ 64 ], EXPR [ (1, _37) 0 ]], outputs: [_38, _39]", + "BLACKBOX::RANGE [(_39, 64)] []", + "EXPR [ (1, _37) (-1, _39) (-1, _40) -1 ]", + "BLACKBOX::RANGE [(_40, 64)] []", + "EXPR [ (-1, _37, _38) (-1, _39) 64 ]", + "EXPR [ (1, _38) -32 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0, _37) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_41, _42]", + "BLACKBOX::RANGE [(_41, 190)] []", + "EXPR [ (1, _0, _37) (-18446744073709551616, _41) (-1, _42) 0 ]", + "EXPR [ (-1, _41) (-1, _43) 1186564023676924939888766319973246049704924238154051448977 ]", + "BLACKBOX::RANGE [(_43, 190)] []", + "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _41) 1186564023676924939888766319973246049704924238154051448977 ]], outputs: [_44]", + "EXPR [ (-1, _41, _44) (1186564023676924939888766319973246049704924238154051448977, _44) (1, _45) -1 ]", + "EXPR [ (-1, _41, _45) (1186564023676924939888766319973246049704924238154051448977, _45) 0 ]", + "EXPR [ (1, _42, _45) (4331911350818177023, _45) (-1, _46) 0 ]", + "BLACKBOX::RANGE [(_46, 63)] []", + "EXPR [ (1, _42) -128 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _37) 0 ]], outputs: [_47]", + "EXPR [ (1, _37, _47) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _37) 0 ]], outputs: [_48, _49]", + "BLACKBOX::RANGE [(_49, 64)] []", + "EXPR [ (1, _37) (-1, _49) (-1, _50) -1 ]", + "BLACKBOX::RANGE [(_50, 64)] []", + "EXPR [ (-1, _37, _48) (1, _0) (-1, _49) 0 ]", + "EXPR [ (1, _48) -32 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 36893488147419103230 ], EXPR [ 18446744073709551616 ]], outputs: [_51, _52]", + "BLACKBOX::RANGE [(_51, 2)] []", + "BLACKBOX::RANGE [(_52, 64)] []", + "EXPR [ (1, _0) (-18446744073709551616, _51) (-1, _52) 36893488147419103230 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 9223372036854775808 ], EXPR [ 18446744073709551616 ]], outputs: [_53, _54]", + "BLACKBOX::RANGE [(_53, 1)] []", + "BLACKBOX::RANGE [(_54, 64)] []", + "EXPR [ (1, _0) (-18446744073709551616, _53) (-1, _54) 9223372036854775808 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _52) 9223372036854775808 ], EXPR [ 18446744073709551616 ]], outputs: [_55, _56]", + "BLACKBOX::RANGE [(_55, 1)] []", + "BLACKBOX::RANGE [(_56, 64)] []", + "EXPR [ (1, _52) (-18446744073709551616, _55) (-1, _56) 9223372036854775808 ]", + "EXPR [ (1, _53) (-1, _55) (-1, _57) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _57) 0 ]], outputs: [_58]", + "EXPR [ (1, _57, _58) (1, _59) -1 ]", + "EXPR [ (1, _57, _59) 0 ]", + "EXPR [ (1, _53, _59) (-1, _53) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _52) 18446744073709551553 ], EXPR [ 18446744073709551616 ]], outputs: [_60, _61]", + "BLACKBOX::RANGE [(_61, 64)] []", + "EXPR [ (1, _52) (-18446744073709551616, _60) (-1, _61) 18446744073709551553 ]", + "EXPR [ (-1, _60) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _52) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_62, _63]", + "BLACKBOX::RANGE [(_62, 1)] []", + "BLACKBOX::RANGE [(_63, 63)] []", + "EXPR [ (1, _52) (-9223372036854775808, _62) (-1, _63) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _52) 36893488147419103168 ], EXPR [ 36893488147419103232 ]], outputs: [_64, _65]", "BLACKBOX::RANGE [(_64, 1)] []", - "BLACKBOX::RANGE [(_65, 1)] []", - "BLACKBOX::RANGE [(_66, 1)] []", + "BLACKBOX::RANGE [(_65, 65)] []", + "EXPR [ (1, _52) (-36893488147419103232, _64) (-1, _65) 36893488147419103168 ]", + "EXPR [ (2, _62, _64) (-1, _62) (-1, _64) (-1, _66) 1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _66, _52) 0 ], EXPR [ 7 ], EXPR [ 2 ]], outputs: [[_67, _68, _69, _70, _71, _72, _73]]", "BLACKBOX::RANGE [(_67, 1)] []", "BLACKBOX::RANGE [(_68, 1)] []", "BLACKBOX::RANGE [(_69, 1)] []", "BLACKBOX::RANGE [(_70, 1)] []", - "EXPR [ (-1, _60, _61) (1, _60) (-1, _63) (-2, _64) (-4, _65) (-8, _66) (-16, _67) (-32, _68) (-64, _69) (-128, _70) 0 ]", - "EXPR [ (1, _70, _70) (2, _70) (-1, _71) 1 ]", - "EXPR [ (-1, _69) (-1, _72) 1 ]", - "EXPR [ (2, _69, _71) (1, _71, _72) (-1, _73) 0 ]", - "EXPR [ (1, _73, _73) (-1, _74) 0 ]", - "EXPR [ (-1, _68) (-1, _75) 1 ]", - "EXPR [ (2, _68, _74) (1, _74, _75) (-1, _76) 0 ]", + "BLACKBOX::RANGE [(_71, 1)] []", + "BLACKBOX::RANGE [(_72, 1)] []", + "BLACKBOX::RANGE [(_73, 1)] []", + "EXPR [ (1, _52, _66) (-1, _67) (-2, _68) (-4, _69) (-8, _70) (-16, _71) (-32, _72) (-64, _73) 0 ]", + "EXPR [ (1, _73, _73) (2, _73) (-1, _74) 1 ]", + "EXPR [ (-1, _72) (-1, _75) 1 ]", + "EXPR [ (2, _72, _74) (1, _74, _75) (-1, _76) 0 ]", "EXPR [ (1, _76, _76) (-1, _77) 0 ]", - "EXPR [ (-1, _67) (-1, _78) 1 ]", - "EXPR [ (2, _67, _77) (1, _77, _78) (-1, _79) 0 ]", + "EXPR [ (-1, _71) (-1, _78) 1 ]", + "EXPR [ (2, _71, _77) (1, _77, _78) (-1, _79) 0 ]", "EXPR [ (1, _79, _79) (-1, _80) 0 ]", - "EXPR [ (-1, _66) (-1, _81) 1 ]", - "EXPR [ (2, _66, _80) (1, _80, _81) (-1, _82) 0 ]", + "EXPR [ (-1, _70) (-1, _81) 1 ]", + "EXPR [ (2, _70, _80) (1, _80, _81) (-1, _82) 0 ]", "EXPR [ (1, _82, _82) (-1, _83) 0 ]", - "EXPR [ (-1, _65) (-1, _84) 1 ]", - "EXPR [ (2, _65, _83) (1, _83, _84) (-1, _85) 0 ]", + "EXPR [ (-1, _69) (-1, _84) 1 ]", + "EXPR [ (2, _69, _83) (1, _83, _84) (-1, _85) 0 ]", "EXPR [ (1, _85, _85) (-1, _86) 0 ]", - "EXPR [ (-1, _64) (-1, _87) 1 ]", - "EXPR [ (2, _64, _86) (1, _86, _87) (-1, _88) 0 ]", + "EXPR [ (-1, _68) (-1, _87) 1 ]", + "EXPR [ (2, _68, _86) (1, _86, _87) (-1, _88) 0 ]", "EXPR [ (1, _88, _88) (-1, _89) 0 ]", - "EXPR [ (-1, _63) (-1, _90) 1 ]", + "EXPR [ (-1, _67) (-1, _90) 1 ]", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _3) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_91, _92]", "BLACKBOX::RANGE [(_91, 1)] []", "BLACKBOX::RANGE [(_92, 63)] []", @@ -200,19 +217,19 @@ expression: artifact "BLACKBOX::RANGE [(_95, 1)] []", "BLACKBOX::RANGE [(_96, 64)] []", "EXPR [ (2, _91, _93) (1, _3) (-1, _91) (-1, _93) (-18446744073709551616, _95) (-1, _96) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _89, _63) (1, _89, _90) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_97, _98]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _89, _67) (1, _89, _90) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_97, _98]", "BLACKBOX::RANGE [(_97, 1)] []", "BLACKBOX::RANGE [(_98, 63)] []", - "EXPR [ (2, _63, _89) (-1, _364) 0 ]", - "EXPR [ (1, _89, _90) (-1, _365) 0 ]", - "EXPR [ (-9223372036854775808, _97) (-1, _98) (1, _364) (1, _365) 0 ]", + "EXPR [ (2, _67, _89) (-1, _428) 0 ]", + "EXPR [ (1, _89, _90) (-1, _429) 0 ]", + "EXPR [ (-9223372036854775808, _97) (-1, _98) (1, _428) (1, _429) 0 ]", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _96) 0 ], EXPR [ 9223372036854775808 ]], outputs: [_99, _100]", "BLACKBOX::RANGE [(_99, 1)] []", "BLACKBOX::RANGE [(_100, 63)] []", "EXPR [ (1, _96) (-9223372036854775808, _99) (-1, _100) 0 ]", - "EXPR [ (-1, _101) (-1, _364) (-1, _365) 9223372036854775808 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _89, _63) (1, _89, _90) (2, _101, _97) 0 ]], outputs: [_102]", - "EXPR [ (2, _97, _101) (-1, _103) (1, _364) (1, _365) 0 ]", + "EXPR [ (-1, _101) (-1, _428) (-1, _429) 9223372036854775808 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _89, _67) (1, _89, _90) (2, _101, _97) 0 ]], outputs: [_102]", + "EXPR [ (2, _97, _101) (-1, _103) (1, _428) (1, _429) 0 ]", "EXPR [ (1, _102, _103) -1 ]", "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _96, _99) (1, _96) (18446744073709551616, _99) 0 ], EXPR [ (1, _103) 0 ]], outputs: [_104, _105]", "BLACKBOX::RANGE [(_104, 64)] []", @@ -237,336 +254,452 @@ expression: artifact "BLACKBOX::RANGE [(_118, 64)] []", "EXPR [ (-2, _91, _93) (1, _111, _112) (1, _91) (1, _93) (-18446744073709551616, _117) (-1, _118) 36893488147419103231 ]", "EXPR [ (36893488147419103230, _91, _93) (-18446744073709551615, _91) (-18446744073709551615, _93) (-1, _119) 18446744073709551615 ]", - "EXPR [ (-1, _61, _118) (1, _61, _119) (1, _118) -18446744073709551615 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _60) 240 ], EXPR [ 256 ]], outputs: [_120, _121]", - "BLACKBOX::RANGE [(_120, 1)] []", - "BLACKBOX::RANGE [(_121, 8)] []", - "EXPR [ (1, _60) (-256, _120) (-1, _121) 240 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _120, _60) (1, _60) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_122, _123, _124, _125, _126, _127, _128, _129]]", - "BLACKBOX::RANGE [(_122, 1)] []", - "BLACKBOX::RANGE [(_123, 1)] []", - "BLACKBOX::RANGE [(_124, 1)] []", - "BLACKBOX::RANGE [(_125, 1)] []", - "BLACKBOX::RANGE [(_126, 1)] []", + "EXPR [ (-1, _66) (-1, _120) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _66, _118) (1, _119, _120) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_121, _122]", + "BLACKBOX::RANGE [(_121, 1)] []", + "EXPR [ (1, _66, _118) (1, _119, _120) (-18446744073709551616, _121) (-1, _122) 0 ]", + "EXPR [ (1, _122) -18446744073709551615 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 0 ], EXPR [ 256 ]], outputs: [_123, _124]", + "BLACKBOX::RANGE [(_123, 56)] []", + "BLACKBOX::RANGE [(_124, 8)] []", + "EXPR [ (1, _1) (-256, _123) (-1, _124) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 256 ]], outputs: [_125, _126]", + "BLACKBOX::RANGE [(_125, 56)] []", + "BLACKBOX::RANGE [(_126, 8)] []", + "EXPR [ (1, _0) (-256, _125) (-1, _126) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _126) 0 ], EXPR [ 256 ]], outputs: [_127, _128]", "BLACKBOX::RANGE [(_127, 1)] []", - "BLACKBOX::RANGE [(_128, 1)] []", + "BLACKBOX::RANGE [(_128, 8)] []", + "EXPR [ (2, _126) (-256, _127) (-1, _128) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _128) 0 ], EXPR [ 256 ]], outputs: [_129, _130]", "BLACKBOX::RANGE [(_129, 1)] []", - "EXPR [ (-1, _60, _120) (1, _60) (-1, _122) (-2, _123) (-4, _124) (-8, _125) (-16, _126) (-32, _127) (-64, _128) (-128, _129) 0 ]", - "EXPR [ (1, _129, _129) (2, _129) (-1, _130) 1 ]", - "EXPR [ (-1, _128) (-1, _131) 1 ]", - "EXPR [ (2, _128, _130) (1, _130, _131) (-1, _132) 0 ]", - "EXPR [ (1, _132, _132) (-1, _133) 0 ]", - "EXPR [ (-1, _127) (-1, _134) 1 ]", - "EXPR [ (2, _127, _133) (1, _133, _134) (-1, _135) 0 ]", - "EXPR [ (1, _135, _135) (-1, _136) 0 ]", - "EXPR [ (-1, _126) (-1, _137) 1 ]", - "EXPR [ (2, _126, _136) (1, _136, _137) (-1, _138) 0 ]", - "EXPR [ (1, _138, _138) (-1, _139) 0 ]", - "EXPR [ (-1, _125) (-1, _140) 1 ]", - "EXPR [ (2, _125, _139) (1, _139, _140) (-1, _141) 0 ]", - "EXPR [ (1, _141, _141) (-1, _142) 0 ]", - "EXPR [ (-1, _124) (-1, _143) 1 ]", - "EXPR [ (2, _124, _142) (1, _142, _143) (-1, _144) 0 ]", - "EXPR [ (1, _144, _144) (-1, _145) 0 ]", - "EXPR [ (-1, _123) (-1, _146) 1 ]", - "EXPR [ (2, _123, _145) (1, _145, _146) (-1, _147) 0 ]", - "EXPR [ (1, _147, _147) (-1, _148) 0 ]", - "EXPR [ (-1, _122) (-1, _149) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 32768 ]], outputs: [_150, _151]", - "BLACKBOX::RANGE [(_150, 1)] []", - "BLACKBOX::RANGE [(_151, 15)] []", - "EXPR [ (1, _2) (-32768, _150) (-1, _151) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 131072 ], EXPR [ 131072 ]], outputs: [_152, _153]", - "BLACKBOX::RANGE [(_152, 1)] []", - "BLACKBOX::RANGE [(_153, 17)] []", - "EXPR [ (1, _2) (-131072, _152) (-1, _153) 131072 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _152, _150) (1, _2) (-1, _150) (-1, _152) 1 ], EXPR [ 65536 ]], outputs: [_154, _155]", - "BLACKBOX::RANGE [(_154, 1)] []", - "BLACKBOX::RANGE [(_155, 16)] []", - "EXPR [ (2, _150, _152) (1, _2) (-1, _150) (-1, _152) (-65536, _154) (-1, _155) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _148, _122) (1, _148, _149) 0 ], EXPR [ 32768 ]], outputs: [_156, _157]", - "BLACKBOX::RANGE [(_156, 1)] []", - "BLACKBOX::RANGE [(_157, 15)] []", - "EXPR [ (2, _122, _148) (-1, _389) 0 ]", - "EXPR [ (1, _148, _149) (-1, _390) 0 ]", - "EXPR [ (-32768, _156) (-1, _157) (1, _389) (1, _390) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _155) 0 ], EXPR [ 32768 ]], outputs: [_158, _159]", + "EXPR [ (1, _128) (-256, _129) (-1, _130) 0 ]", + "EXPR [ (1, _130) -128 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _126) 0 ], EXPR [ 128 ]], outputs: [_131, _132]", + "BLACKBOX::RANGE [(_131, 1)] []", + "BLACKBOX::RANGE [(_132, 7)] []", + "EXPR [ (1, _126) (-128, _131) (-1, _132) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _126) 512 ], EXPR [ 512 ]], outputs: [_133, _134]", + "BLACKBOX::RANGE [(_133, 1)] []", + "BLACKBOX::RANGE [(_134, 9)] []", + "EXPR [ (1, _126) (-512, _133) (-1, _134) 512 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _133, _131) (1, _126) (-1, _131) (-1, _133) 1 ], EXPR [ 256 ]], outputs: [_135, _136]", + "BLACKBOX::RANGE [(_135, 1)] []", + "BLACKBOX::RANGE [(_136, 8)] []", + "EXPR [ (2, _131, _133) (1, _126) (-1, _131) (-1, _133) (-256, _135) (-1, _136) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _136) 0 ], EXPR [ 128 ]], outputs: [_137, _138]", + "BLACKBOX::RANGE [(_137, 1)] []", + "BLACKBOX::RANGE [(_138, 7)] []", + "EXPR [ (1, _136) (-128, _137) (-1, _138) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _136, _137) (1, _136) (256, _137) 0 ], EXPR [ 4 ]], outputs: [_139, _140]", + "BLACKBOX::RANGE [(_139, 6)] []", + "BLACKBOX::RANGE [(_140, 2)] []", + "EXPR [ (-2, _136, _137) (1, _136) (256, _137) (-4, _139) (-1, _140) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _139) 0 ]], outputs: [_141]", + "EXPR [ (1, _139, _141) (1, _142) -1 ]", + "EXPR [ (1, _139, _142) 0 ]", + "EXPR [ (-2, _137, _139) (256, _137) (1, _139) (-1, _143) 0 ]", + "EXPR [ (-1, _142) (-1, _144) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _140) 0 ]], outputs: [_145]", + "EXPR [ (1, _140, _145) (1, _146) -1 ]", + "EXPR [ (1, _140, _146) 0 ]", + "EXPR [ (-2, _137, _140) (256, _137) (1, _140) (-1, _147) 0 ]", + "EXPR [ (-1, _146) (-1, _148) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _133, _131) (1, _143, _144) (1, _131) (1, _133) 511 ], EXPR [ 256 ]], outputs: [_149, _150]", + "BLACKBOX::RANGE [(_149, 2)] []", + "EXPR [ (-2, _131, _133) (1, _143, _144) (1, _131) (1, _133) (-256, _149) (-1, _150) 511 ]", + "EXPR [ (1, _150) -16 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _124) 249 ], EXPR [ 256 ]], outputs: [_151, _152]", + "BLACKBOX::RANGE [(_152, 8)] []", + "EXPR [ (1, _124) (-256, _151) (-1, _152) 249 ]", + "EXPR [ (-1, _151) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _124) 0 ], EXPR [ 128 ]], outputs: [_153, _154]", + "BLACKBOX::RANGE [(_153, 1)] []", + "BLACKBOX::RANGE [(_154, 7)] []", + "EXPR [ (1, _124) (-128, _153) (-1, _154) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _124) 504 ], EXPR [ 512 ]], outputs: [_155, _156]", + "BLACKBOX::RANGE [(_155, 1)] []", + "BLACKBOX::RANGE [(_156, 9)] []", + "EXPR [ (1, _124) (-512, _155) (-1, _156) 504 ]", + "EXPR [ (2, _153, _155) (-1, _153) (-1, _155) (-1, _157) 1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _157, _124) 0 ], EXPR [ 4 ], EXPR [ 2 ]], outputs: [[_158, _159, _160, _161]]", "BLACKBOX::RANGE [(_158, 1)] []", - "BLACKBOX::RANGE [(_159, 15)] []", - "EXPR [ (1, _155) (-32768, _158) (-1, _159) 0 ]", - "EXPR [ (-1, _160) (-1, _389) (-1, _390) 32768 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _148, _122) (1, _148, _149) (2, _160, _156) 0 ]], outputs: [_161]", - "EXPR [ (2, _156, _160) (-1, _162) (1, _389) (1, _390) 0 ]", - "EXPR [ (1, _161, _162) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _155, _158) (1, _155) (65536, _158) 0 ], EXPR [ (1, _162) 0 ]], outputs: [_163, _164]", - "BLACKBOX::RANGE [(_163, 16)] []", - "BLACKBOX::RANGE [(_164, 16)] []", - "EXPR [ (1, _162) (-1, _164) (-1, _165) -1 ]", - "BLACKBOX::RANGE [(_165, 16)] []", - "EXPR [ (-2, _155, _158) (-1, _162, _163) (1, _155) (65536, _158) (-1, _164) 0 ]", - "EXPR [ (-1, _163) (-1, _166) 32768 ]", - "EXPR [ (-2, _156, _158) (1, _156) (1, _158) (-1, _167) 0 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _163) 0 ]], outputs: [_168]", - "EXPR [ (1, _163, _168) (1, _169) -1 ]", - "EXPR [ (1, _163, _169) 0 ]", - "EXPR [ (2, _166, _167) (1, _163) (-1, _170) 0 ]", - "EXPR [ (-1, _169) (-1, _171) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _164) 0 ]], outputs: [_172]", - "EXPR [ (1, _164, _172) (1, _173) -1 ]", - "EXPR [ (1, _164, _173) 0 ]", - "EXPR [ (-2, _158, _164) (65536, _158) (1, _164) (-1, _174) 0 ]", - "EXPR [ (-1, _173) (-1, _175) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _152, _150) (1, _170, _171) (1, _150) (1, _152) 131071 ], EXPR [ 65536 ]], outputs: [_176, _177]", - "BLACKBOX::RANGE [(_176, 2)] []", - "BLACKBOX::RANGE [(_177, 16)] []", - "EXPR [ (-2, _150, _152) (1, _170, _171) (1, _150) (1, _152) (-65536, _176) (-1, _177) 131071 ]", - "EXPR [ (131070, _150, _152) (-65535, _150) (-65535, _152) (-1, _178) 65535 ]", - "EXPR [ (-1, _120, _177) (1, _120, _178) (1, _177) -65535 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _60) 0 ], EXPR [ 256 ]], outputs: [_179, _180]", - "BLACKBOX::RANGE [(_179, 1)] []", - "BLACKBOX::RANGE [(_180, 8)] []", - "EXPR [ (2, _60) (-256, _179) (-1, _180) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _180) 0 ], EXPR [ 256 ]], outputs: [_181, _182]", - "BLACKBOX::RANGE [(_181, 1)] []", - "EXPR [ (1, _180) (-256, _181) (-1, _182) 0 ]", - "EXPR [ (1, _182) -128 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _60) 0 ], EXPR [ 128 ]], outputs: [_183, _184]", - "BLACKBOX::RANGE [(_183, 1)] []", - "BLACKBOX::RANGE [(_184, 7)] []", - "EXPR [ (1, _60) (-128, _183) (-1, _184) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _60) 512 ], EXPR [ 512 ]], outputs: [_185, _186]", - "BLACKBOX::RANGE [(_185, 1)] []", - "BLACKBOX::RANGE [(_186, 9)] []", - "EXPR [ (1, _60) (-512, _185) (-1, _186) 512 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _185, _183) (1, _60) (-1, _183) (-1, _185) 1 ], EXPR [ 256 ]], outputs: [_187, _188]", - "BLACKBOX::RANGE [(_187, 1)] []", - "BLACKBOX::RANGE [(_188, 8)] []", - "EXPR [ (2, _183, _185) (1, _60) (-1, _183) (-1, _185) (-256, _187) (-1, _188) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _188) 0 ], EXPR [ 128 ]], outputs: [_189, _190]", - "BLACKBOX::RANGE [(_189, 1)] []", - "BLACKBOX::RANGE [(_190, 7)] []", - "EXPR [ (1, _188) (-128, _189) (-1, _190) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _188, _189) (1, _188) (256, _189) 0 ], EXPR [ 4 ]], outputs: [_191, _192]", - "BLACKBOX::RANGE [(_191, 6)] []", - "BLACKBOX::RANGE [(_192, 2)] []", - "EXPR [ (-2, _188, _189) (1, _188) (256, _189) (-4, _191) (-1, _192) 0 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _191) 0 ]], outputs: [_193]", - "EXPR [ (1, _191, _193) (1, _194) -1 ]", - "EXPR [ (1, _191, _194) 0 ]", - "EXPR [ (-2, _189, _191) (256, _189) (1, _191) (-1, _195) 0 ]", - "EXPR [ (-1, _194) (-1, _196) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _192) 0 ]], outputs: [_197]", - "EXPR [ (1, _192, _197) (1, _198) -1 ]", - "EXPR [ (1, _192, _198) 0 ]", - "EXPR [ (-2, _189, _192) (256, _189) (1, _192) (-1, _199) 0 ]", - "EXPR [ (-1, _198) (-1, _200) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _185, _183) (1, _195, _196) (1, _183) (1, _185) 511 ], EXPR [ 256 ]], outputs: [_201, _202]", - "BLACKBOX::RANGE [(_201, 2)] []", - "EXPR [ (-2, _183, _185) (1, _195, _196) (1, _183) (1, _185) (-256, _201) (-1, _202) 511 ]", - "EXPR [ (1, _202) -16 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 248 ], EXPR [ 256 ]], outputs: [_203, _204]", - "BLACKBOX::RANGE [(_204, 8)] []", - "EXPR [ (1, _1) (-256, _203) (-1, _204) 248 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _203, _1) (1, _1) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_205, _206, _207, _208, _209, _210, _211, _212]]", - "BLACKBOX::RANGE [(_205, 1)] []", - "BLACKBOX::RANGE [(_206, 1)] []", - "BLACKBOX::RANGE [(_207, 1)] []", + "BLACKBOX::RANGE [(_159, 1)] []", + "BLACKBOX::RANGE [(_160, 1)] []", + "BLACKBOX::RANGE [(_161, 1)] []", + "EXPR [ (1, _124, _157) (-1, _158) (-2, _159) (-4, _160) (-8, _161) 0 ]", + "EXPR [ (1, _161, _161) (2, _161) (-1, _162) 1 ]", + "EXPR [ (-1, _160) (-1, _163) 1 ]", + "EXPR [ (2, _160, _162) (1, _162, _163) (-1, _164) 0 ]", + "EXPR [ (1, _164, _164) (-1, _165) 0 ]", + "EXPR [ (-1, _159) (-1, _166) 1 ]", + "EXPR [ (2, _159, _165) (1, _165, _166) (-1, _167) 0 ]", + "EXPR [ (1, _167, _167) (-1, _168) 0 ]", + "EXPR [ (-1, _158) (-1, _169) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _168, _158) (1, _168, _169) 0 ], EXPR [ 128 ]], outputs: [_170, _171]", + "BLACKBOX::RANGE [(_170, 1)] []", + "BLACKBOX::RANGE [(_171, 7)] []", + "EXPR [ (2, _158, _168) (-1, _444) 0 ]", + "EXPR [ (1, _168, _169) (-1, _445) 0 ]", + "EXPR [ (-128, _170) (-1, _171) (1, _444) (1, _445) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _136) 0 ], EXPR [ 128 ]], outputs: [_172, _173]", + "BLACKBOX::RANGE [(_172, 1)] []", + "BLACKBOX::RANGE [(_173, 7)] []", + "EXPR [ (1, _136) (-128, _172) (-1, _173) 0 ]", + "EXPR [ (-1, _174) (-1, _444) (-1, _445) 128 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _168, _158) (1, _168, _169) (2, _174, _170) 0 ]], outputs: [_175]", + "EXPR [ (2, _170, _174) (-1, _176) (1, _444) (1, _445) 0 ]", + "EXPR [ (1, _175, _176) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _136, _172) (1, _136) (256, _172) 0 ], EXPR [ (1, _176) 0 ]], outputs: [_177, _178]", + "BLACKBOX::RANGE [(_177, 8)] []", + "BLACKBOX::RANGE [(_178, 8)] []", + "EXPR [ (1, _176) (-1, _178) (-1, _179) -1 ]", + "BLACKBOX::RANGE [(_179, 8)] []", + "EXPR [ (-2, _136, _172) (-1, _176, _177) (1, _136) (256, _172) (-1, _178) 0 ]", + "EXPR [ (-1, _177) (-1, _180) 128 ]", + "EXPR [ (-2, _170, _172) (1, _170) (1, _172) (-1, _181) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _177) 0 ]], outputs: [_182]", + "EXPR [ (1, _177, _182) (1, _183) -1 ]", + "EXPR [ (1, _177, _183) 0 ]", + "EXPR [ (2, _180, _181) (1, _177) (-1, _184) 0 ]", + "EXPR [ (-1, _183) (-1, _185) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _178) 0 ]], outputs: [_186]", + "EXPR [ (1, _178, _186) (1, _187) -1 ]", + "EXPR [ (1, _178, _187) 0 ]", + "EXPR [ (-2, _172, _178) (256, _172) (1, _178) (-1, _188) 0 ]", + "EXPR [ (-1, _187) (-1, _189) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _133, _131) (1, _184, _185) (1, _131) (1, _133) 511 ], EXPR [ 256 ]], outputs: [_190, _191]", + "BLACKBOX::RANGE [(_190, 2)] []", + "BLACKBOX::RANGE [(_191, 8)] []", + "EXPR [ (-2, _131, _133) (1, _184, _185) (1, _131) (1, _133) (-256, _190) (-1, _191) 511 ]", + "EXPR [ (510, _131, _133) (-255, _131) (-255, _133) (-1, _192) 255 ]", + "EXPR [ (-1, _157) (-1, _193) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _157, _191) (1, _192, _193) 0 ], EXPR [ 256 ]], outputs: [_194, _195]", + "BLACKBOX::RANGE [(_194, 1)] []", + "EXPR [ (1, _157, _191) (1, _192, _193) (-256, _194) (-1, _195) 0 ]", + "EXPR [ (1, _195) -32 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _124) 512 ], EXPR [ 256 ]], outputs: [_196, _197]", + "BLACKBOX::RANGE [(_196, 2)] []", + "BLACKBOX::RANGE [(_197, 8)] []", + "EXPR [ (-1, _124) (-256, _196) (-1, _197) 512 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _124) 128 ], EXPR [ 256 ]], outputs: [_198, _199]", + "BLACKBOX::RANGE [(_198, 1)] []", + "BLACKBOX::RANGE [(_199, 8)] []", + "EXPR [ (1, _124) (-256, _198) (-1, _199) 128 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _197) 128 ], EXPR [ 256 ]], outputs: [_200, _201]", + "BLACKBOX::RANGE [(_200, 1)] []", + "BLACKBOX::RANGE [(_201, 8)] []", + "EXPR [ (1, _197) (-256, _200) (-1, _201) 128 ]", + "EXPR [ (-1, _198, _200) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (64, _197) 0 ], EXPR [ 256 ]], outputs: [_202, _203]", + "BLACKBOX::RANGE [(_202, 6)] []", + "BLACKBOX::RANGE [(_203, 8)] []", + "EXPR [ (64, _197) (-256, _202) (-1, _203) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _203) 0 ], EXPR [ 256 ]], outputs: [_204, _205]", + "BLACKBOX::RANGE [(_204, 1)] []", + "EXPR [ (1, _203) (-256, _204) (-1, _205) 0 ]", + "EXPR [ (1, _205) -192 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _197) 512 ], EXPR [ 256 ]], outputs: [_206, _207]", + "BLACKBOX::RANGE [(_206, 2)] []", + "BLACKBOX::RANGE [(_207, 8)] []", + "EXPR [ (-1, _197) (-256, _206) (-1, _207) 512 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _207) 128 ], EXPR [ 256 ]], outputs: [_208, _209]", "BLACKBOX::RANGE [(_208, 1)] []", - "BLACKBOX::RANGE [(_209, 1)] []", - "BLACKBOX::RANGE [(_210, 1)] []", - "BLACKBOX::RANGE [(_211, 1)] []", + "BLACKBOX::RANGE [(_209, 8)] []", + "EXPR [ (1, _207) (-256, _208) (-1, _209) 128 ]", + "EXPR [ (-1, _200, _208) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _207) 249 ], EXPR [ 256 ]], outputs: [_210, _211]", + "BLACKBOX::RANGE [(_211, 8)] []", + "EXPR [ (1, _207) (-256, _210) (-1, _211) 249 ]", + "EXPR [ (-1, _210) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _207) 0 ], EXPR [ 128 ]], outputs: [_212, _213]", "BLACKBOX::RANGE [(_212, 1)] []", - "EXPR [ (-1, _1, _203) (1, _1) (-1, _205) (-2, _206) (-4, _207) (-8, _208) (-16, _209) (-32, _210) (-64, _211) (-128, _212) 0 ]", - "EXPR [ (1, _212, _212) (2, _212) (-1, _213) 1 ]", - "EXPR [ (-1, _211) (-1, _214) 1 ]", - "EXPR [ (2, _211, _213) (1, _213, _214) (-1, _215) 0 ]", - "EXPR [ (1, _215, _215) (-1, _216) 0 ]", - "EXPR [ (-1, _210) (-1, _217) 1 ]", - "EXPR [ (2, _210, _216) (1, _216, _217) (-1, _218) 0 ]", - "EXPR [ (1, _218, _218) (-1, _219) 0 ]", - "EXPR [ (-1, _209) (-1, _220) 1 ]", - "EXPR [ (2, _209, _219) (1, _219, _220) (-1, _221) 0 ]", - "EXPR [ (1, _221, _221) (-1, _222) 0 ]", - "EXPR [ (-1, _208) (-1, _223) 1 ]", - "EXPR [ (2, _208, _222) (1, _222, _223) (-1, _224) 0 ]", - "EXPR [ (1, _224, _224) (-1, _225) 0 ]", - "EXPR [ (-1, _207) (-1, _226) 1 ]", - "EXPR [ (2, _207, _225) (1, _225, _226) (-1, _227) 0 ]", - "EXPR [ (1, _227, _227) (-1, _228) 0 ]", - "EXPR [ (-1, _206) (-1, _229) 1 ]", - "EXPR [ (2, _206, _228) (1, _228, _229) (-1, _230) 0 ]", - "EXPR [ (1, _230, _230) (-1, _231) 0 ]", - "EXPR [ (-1, _205) (-1, _232) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _231, _205) (1, _231, _232) 0 ], EXPR [ 128 ]], outputs: [_233, _234]", - "BLACKBOX::RANGE [(_233, 1)] []", - "BLACKBOX::RANGE [(_234, 7)] []", - "EXPR [ (2, _205, _231) (-1, _415) 0 ]", - "EXPR [ (1, _231, _232) (-1, _416) 0 ]", - "EXPR [ (-128, _233) (-1, _234) (1, _415) (1, _416) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _188) 0 ], EXPR [ 128 ]], outputs: [_235, _236]", - "BLACKBOX::RANGE [(_235, 1)] []", - "BLACKBOX::RANGE [(_236, 7)] []", - "EXPR [ (1, _188) (-128, _235) (-1, _236) 0 ]", - "EXPR [ (-1, _237) (-1, _415) (-1, _416) 128 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _231, _205) (1, _231, _232) (2, _237, _233) 0 ]], outputs: [_238]", - "EXPR [ (2, _233, _237) (-1, _239) (1, _415) (1, _416) 0 ]", - "EXPR [ (1, _238, _239) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _188, _235) (1, _188) (256, _235) 0 ], EXPR [ (1, _239) 0 ]], outputs: [_240, _241]", - "BLACKBOX::RANGE [(_240, 8)] []", - "BLACKBOX::RANGE [(_241, 8)] []", - "EXPR [ (1, _239) (-1, _241) (-1, _242) -1 ]", - "BLACKBOX::RANGE [(_242, 8)] []", - "EXPR [ (-2, _188, _235) (-1, _239, _240) (1, _188) (256, _235) (-1, _241) 0 ]", - "EXPR [ (-1, _240) (-1, _243) 128 ]", - "EXPR [ (-2, _233, _235) (1, _233) (1, _235) (-1, _244) 0 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _240) 0 ]], outputs: [_245]", - "EXPR [ (1, _240, _245) (1, _246) -1 ]", - "EXPR [ (1, _240, _246) 0 ]", - "EXPR [ (2, _243, _244) (1, _240) (-1, _247) 0 ]", - "EXPR [ (-1, _246) (-1, _248) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _241) 0 ]], outputs: [_249]", - "EXPR [ (1, _241, _249) (1, _250) -1 ]", - "EXPR [ (1, _241, _250) 0 ]", - "EXPR [ (-2, _235, _241) (256, _235) (1, _241) (-1, _251) 0 ]", - "EXPR [ (-1, _250) (-1, _252) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _185, _183) (1, _247, _248) (1, _183) (1, _185) 511 ], EXPR [ 256 ]], outputs: [_253, _254]", - "BLACKBOX::RANGE [(_253, 2)] []", - "BLACKBOX::RANGE [(_254, 8)] []", - "EXPR [ (-2, _183, _185) (1, _247, _248) (1, _183) (1, _185) (-256, _253) (-1, _254) 511 ]", - "EXPR [ (510, _183, _185) (-255, _183) (-255, _185) (-1, _255) 255 ]", - "EXPR [ (-1, _203, _254) (1, _203, _255) (1, _254) -32 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _1) 512 ], EXPR [ 256 ]], outputs: [_256, _257]", - "BLACKBOX::RANGE [(_256, 2)] []", - "BLACKBOX::RANGE [(_257, 8)] []", - "EXPR [ (-1, _1) (-256, _256) (-1, _257) 512 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 128 ], EXPR [ 256 ]], outputs: [_258, _259]", - "BLACKBOX::RANGE [(_258, 1)] []", - "BLACKBOX::RANGE [(_259, 8)] []", - "EXPR [ (1, _1) (-256, _258) (-1, _259) 128 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _257) 128 ], EXPR [ 256 ]], outputs: [_260, _261]", - "BLACKBOX::RANGE [(_260, 1)] []", - "BLACKBOX::RANGE [(_261, 8)] []", - "EXPR [ (1, _257) (-256, _260) (-1, _261) 128 ]", - "EXPR [ (-1, _258, _260) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (128, _257) 0 ], EXPR [ 256 ]], outputs: [_262, _263]", - "BLACKBOX::RANGE [(_262, 7)] []", - "BLACKBOX::RANGE [(_263, 8)] []", - "EXPR [ (128, _257) (-256, _262) (-1, _263) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _263) 0 ], EXPR [ 256 ]], outputs: [_264, _265]", - "BLACKBOX::RANGE [(_264, 1)] []", - "EXPR [ (1, _263) (-256, _264) (-1, _265) 0 ]", - "EXPR [ (1, _265) -128 ]", - "EXPR [ (-1, _35, _203) (1, _35) (-1, _266) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _257, _266) 0 ], EXPR [ 256 ]], outputs: [_267, _268]", - "BLACKBOX::RANGE [(_267, 246)] []", - "BLACKBOX::RANGE [(_268, 8)] []", - "EXPR [ (1, _257, _266) (-256, _267) (-1, _268) 0 ]", - "EXPR [ (-1, _267) (-1, _269) 85500948718122168836900022442411230814642048439125134155071110103811751936 ]", - "BLACKBOX::RANGE [(_269, 246)] []", - "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _267) 85500948718122168836900022442411230814642048439125134155071110103811751936 ]], outputs: [_270]", - "EXPR [ (-1, _267, _270) (85500948718122168836900022442411230814642048439125134155071110103811751936, _270) (1, _271) -1 ]", - "EXPR [ (-1, _267, _271) (85500948718122168836900022442411230814642048439125134155071110103811751936, _271) 0 ]", - "EXPR [ (1, _268, _271) (-1, _272) 0 ]", - "BLACKBOX::RANGE [(_272, 0)] []", - "EXPR [ (-1, _203) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _268) 0 ], EXPR [ 256 ]], outputs: [_273, _274]", + "BLACKBOX::RANGE [(_213, 7)] []", + "EXPR [ (1, _207) (-128, _212) (-1, _213) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _207) 504 ], EXPR [ 512 ]], outputs: [_214, _215]", + "BLACKBOX::RANGE [(_214, 1)] []", + "BLACKBOX::RANGE [(_215, 9)] []", + "EXPR [ (1, _207) (-512, _214) (-1, _215) 504 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _207) 0 ], EXPR [ 4 ], EXPR [ 2 ]], outputs: [[_216, _217, _218, _219]]", + "BLACKBOX::RANGE [(_216, 1)] []", + "BLACKBOX::RANGE [(_217, 1)] []", + "BLACKBOX::RANGE [(_218, 1)] []", + "BLACKBOX::RANGE [(_219, 1)] []", + "EXPR [ (1, _207) (-1, _216) (-2, _217) (-4, _218) (-8, _219) 0 ]", + "EXPR [ (1, _219, _219) (2, _219) (-1, _220) 1 ]", + "EXPR [ (-1, _218) (-1, _221) 1 ]", + "EXPR [ (2, _218, _220) (1, _220, _221) (-1, _222) 0 ]", + "EXPR [ (1, _222, _222) (-1, _223) 0 ]", + "EXPR [ (-1, _217) (-1, _224) 1 ]", + "EXPR [ (2, _217, _223) (1, _223, _224) (-1, _225) 0 ]", + "EXPR [ (1, _225, _225) (-1, _226) 0 ]", + "EXPR [ (-1, _216) (-1, _227) 1 ]", + "EXPR [ (2, _212, _214) (-1, _212) (-1, _214) (-1, _228) 1 ]", + "EXPR [ (2, _216, _226) (1, _226, _227) (-1, _229) 0 ]", + "EXPR [ (1, _228, _229) (-1, _230) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _197, _230) 0 ], EXPR [ 256 ]], outputs: [_231, _232]", + "BLACKBOX::RANGE [(_231, 246)] []", + "BLACKBOX::RANGE [(_232, 8)] []", + "EXPR [ (1, _197, _230) (-256, _231) (-1, _232) 0 ]", + "EXPR [ (-1, _231) (-1, _233) 85500948718122168836900022442411230814642048439125134155071110103811751936 ]", + "BLACKBOX::RANGE [(_233, 246)] []", + "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _231) 85500948718122168836900022442411230814642048439125134155071110103811751936 ]], outputs: [_234]", + "EXPR [ (-1, _231, _234) (85500948718122168836900022442411230814642048439125134155071110103811751936, _234) (1, _235) -1 ]", + "EXPR [ (-1, _231, _235) (85500948718122168836900022442411230814642048439125134155071110103811751936, _235) 0 ]", + "EXPR [ (1, _232, _235) (-1, _236) 0 ]", + "BLACKBOX::RANGE [(_236, 0)] []", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _232) 0 ], EXPR [ 256 ]], outputs: [_237, _238]", + "BLACKBOX::RANGE [(_237, 1)] []", + "EXPR [ (1, _232) (-256, _237) (-1, _238) 0 ]", + "EXPR [ (1, _238) -254 ]", + "EXPR [ (1, _0) (-1, _239) -1 ]", + "BLACKBOX::RANGE [(_239, 64)] []", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _239) 18446744073709551552 ], EXPR [ 18446744073709551616 ]], outputs: [_240, _241]", + "BLACKBOX::RANGE [(_241, 64)] []", + "EXPR [ (1, _239) (-18446744073709551616, _240) (-1, _241) 18446744073709551552 ]", + "EXPR [ (-1, _240) 0 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _239) 0 ], EXPR [ 7 ], EXPR [ 2 ]], outputs: [[_242, _243, _244, _245, _246, _247, _248]]", + "BLACKBOX::RANGE [(_242, 1)] []", + "BLACKBOX::RANGE [(_243, 1)] []", + "BLACKBOX::RANGE [(_244, 1)] []", + "BLACKBOX::RANGE [(_245, 1)] []", + "BLACKBOX::RANGE [(_246, 1)] []", + "BLACKBOX::RANGE [(_247, 1)] []", + "BLACKBOX::RANGE [(_248, 1)] []", + "EXPR [ (1, _239) (-1, _242) (-2, _243) (-4, _244) (-8, _245) (-16, _246) (-32, _247) (-64, _248) 0 ]", + "EXPR [ (1, _248, _248) (2, _248) (-1, _249) 1 ]", + "EXPR [ (-1, _247) (-1, _250) 1 ]", + "EXPR [ (2, _247, _249) (1, _249, _250) (-1, _251) 0 ]", + "EXPR [ (1, _251, _251) (-1, _252) 0 ]", + "EXPR [ (-1, _246) (-1, _253) 1 ]", + "EXPR [ (2, _246, _252) (1, _252, _253) (-1, _254) 0 ]", + "EXPR [ (1, _254, _254) (-1, _255) 0 ]", + "EXPR [ (-1, _245) (-1, _256) 1 ]", + "EXPR [ (2, _245, _255) (1, _255, _256) (-1, _257) 0 ]", + "EXPR [ (1, _257, _257) (-1, _258) 0 ]", + "EXPR [ (-1, _244) (-1, _259) 1 ]", + "EXPR [ (2, _244, _258) (1, _258, _259) (-1, _260) 0 ]", + "EXPR [ (1, _260, _260) (-1, _261) 0 ]", + "EXPR [ (-1, _243) (-1, _262) 1 ]", + "EXPR [ (2, _243, _261) (1, _261, _262) (-1, _263) 0 ]", + "EXPR [ (1, _263, _263) (-1, _264) 0 ]", + "EXPR [ (-1, _242) (-1, _265) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _264, _242) (1, _264, _265) 0 ]], outputs: [_266]", + "EXPR [ (2, _242, _264) (1, _264, _265) (-1, _267) 0 ]", + "EXPR [ (1, _266, _267) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _267) 0 ]], outputs: [_268, _269]", + "BLACKBOX::RANGE [(_269, 64)] []", + "EXPR [ (1, _267) (-1, _269) (-1, _270) -1 ]", + "BLACKBOX::RANGE [(_270, 64)] []", + "EXPR [ (-1, _267, _268) (1, _0) (-1, _269) 0 ]", + "EXPR [ (1, _268) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 32768 ]], outputs: [_271, _272]", + "BLACKBOX::RANGE [(_271, 1)] []", + "BLACKBOX::RANGE [(_272, 15)] []", + "EXPR [ (1, _2) (-32768, _271) (-1, _272) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 131072 ], EXPR [ 131072 ]], outputs: [_273, _274]", "BLACKBOX::RANGE [(_273, 1)] []", - "EXPR [ (1, _268) (-256, _273) (-1, _274) 0 ]", - "EXPR [ (1, _274) -254 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _89, _63) (1, _89, _90) 0 ]], outputs: [_275]", - "EXPR [ (-1, _276) (1, _364) (1, _365) 0 ]", - "EXPR [ (1, _275, _276) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _276) 0 ]], outputs: [_277, _278]", - "BLACKBOX::RANGE [(_277, 64)] []", - "BLACKBOX::RANGE [(_278, 64)] []", - "EXPR [ (1, _276) (-1, _278) (-1, _279) -1 ]", - "BLACKBOX::RANGE [(_279, 64)] []", - "EXPR [ (-1, _276, _277) (1, _0) (-1, _278) 0 ]", - "EXPR [ (-1, _61, _277) (1, _277) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _155) 0 ], EXPR [ 32768 ]], outputs: [_280, _281]", - "BLACKBOX::RANGE [(_280, 1)] []", - "BLACKBOX::RANGE [(_281, 15)] []", - "EXPR [ (1, _155) (-32768, _280) (-1, _281) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _155, _280) (1, _155) (65536, _280) 0 ], EXPR [ 8 ]], outputs: [_282, _283]", - "BLACKBOX::RANGE [(_282, 13)] []", - "BLACKBOX::RANGE [(_283, 3)] []", - "EXPR [ (-2, _155, _280) (1, _155) (65536, _280) (-8, _282) (-1, _283) 0 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _282) 0 ]], outputs: [_284]", - "EXPR [ (1, _282, _284) (1, _285) -1 ]", - "EXPR [ (1, _282, _285) 0 ]", - "EXPR [ (-2, _280, _282) (65536, _280) (1, _282) (-1, _286) 0 ]", - "EXPR [ (-1, _285) (-1, _287) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _283) 0 ]], outputs: [_288]", - "EXPR [ (1, _283, _288) (1, _289) -1 ]", - "EXPR [ (1, _283, _289) 0 ]", - "EXPR [ (-2, _280, _283) (65536, _280) (1, _283) (-1, _290) 0 ]", - "EXPR [ (-1, _289) (-1, _291) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _152, _150) (1, _286, _287) (1, _150) (1, _152) 131071 ], EXPR [ 65536 ]], outputs: [_292, _293]", - "BLACKBOX::RANGE [(_292, 2)] []", - "EXPR [ (-2, _150, _152) (1, _286, _287) (1, _150) (1, _152) (-65536, _292) (-1, _293) 131071 ]", - "EXPR [ (1, _293) -65439 ]", - "EXPR [ (1, _178) -65535 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _2) 131072 ], EXPR [ 65536 ]], outputs: [_294, _295]", - "BLACKBOX::RANGE [(_294, 2)] []", - "BLACKBOX::RANGE [(_295, 16)] []", - "EXPR [ (-1, _2) (-65536, _294) (-1, _295) 131072 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 32768 ], EXPR [ 65536 ]], outputs: [_296, _297]", - "BLACKBOX::RANGE [(_296, 1)] []", - "BLACKBOX::RANGE [(_297, 16)] []", - "EXPR [ (1, _2) (-65536, _296) (-1, _297) 32768 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _295) 32768 ], EXPR [ 65536 ]], outputs: [_298, _299]", - "BLACKBOX::RANGE [(_298, 1)] []", - "BLACKBOX::RANGE [(_299, 16)] []", - "EXPR [ (1, _295) (-65536, _298) (-1, _299) 32768 ]", - "EXPR [ (-1, _296, _298) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _295) 0 ], EXPR [ 32768 ]], outputs: [_300, _301]", - "BLACKBOX::RANGE [(_300, 1)] []", - "BLACKBOX::RANGE [(_301, 15)] []", - "EXPR [ (1, _295) (-32768, _300) (-1, _301) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _295) 131072 ], EXPR [ 131072 ]], outputs: [_302, _303]", - "BLACKBOX::RANGE [(_302, 1)] []", - "BLACKBOX::RANGE [(_303, 17)] []", - "EXPR [ (1, _295) (-131072, _302) (-1, _303) 131072 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _302, _300) (1, _295) (-1, _300) (-1, _302) 1 ], EXPR [ 65536 ]], outputs: [_304, _305]", - "BLACKBOX::RANGE [(_304, 1)] []", - "BLACKBOX::RANGE [(_305, 16)] []", - "EXPR [ (2, _300, _302) (1, _295) (-1, _300) (-1, _302) (-65536, _304) (-1, _305) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (2, _148, _122) (1, _148, _149) 0 ], EXPR [ 32768 ]], outputs: [_306, _307]", - "BLACKBOX::RANGE [(_306, 1)] []", - "BLACKBOX::RANGE [(_307, 15)] []", - "EXPR [ (-32768, _306) (-1, _307) (1, _389) (1, _390) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _305) 0 ], EXPR [ 32768 ]], outputs: [_308, _309]", - "BLACKBOX::RANGE [(_308, 1)] []", - "BLACKBOX::RANGE [(_309, 15)] []", - "EXPR [ (1, _305) (-32768, _308) (-1, _309) 0 ]", - "EXPR [ (-1, _310) (-1, _389) (-1, _390) 32768 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _148, _122) (1, _148, _149) (2, _310, _306) 0 ]], outputs: [_311]", - "EXPR [ (2, _306, _310) (-1, _312) (1, _389) (1, _390) 0 ]", - "EXPR [ (1, _311, _312) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _305, _308) (1, _305) (65536, _308) 0 ], EXPR [ (1, _312) 0 ]], outputs: [_313, _314]", + "BLACKBOX::RANGE [(_274, 17)] []", + "EXPR [ (1, _2) (-131072, _273) (-1, _274) 131072 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _273, _271) (1, _2) (-1, _271) (-1, _273) 1 ], EXPR [ 65536 ]], outputs: [_275, _276]", + "BLACKBOX::RANGE [(_275, 1)] []", + "BLACKBOX::RANGE [(_276, 16)] []", + "EXPR [ (2, _271, _273) (1, _2) (-1, _271) (-1, _273) (-65536, _275) (-1, _276) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _276) 0 ], EXPR [ 32768 ]], outputs: [_277, _278]", + "BLACKBOX::RANGE [(_277, 1)] []", + "BLACKBOX::RANGE [(_278, 15)] []", + "EXPR [ (1, _276) (-32768, _277) (-1, _278) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _276, _277) (1, _276) (65536, _277) 0 ], EXPR [ 8 ]], outputs: [_279, _280]", + "BLACKBOX::RANGE [(_279, 13)] []", + "BLACKBOX::RANGE [(_280, 3)] []", + "EXPR [ (-2, _276, _277) (1, _276) (65536, _277) (-8, _279) (-1, _280) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _279) 0 ]], outputs: [_281]", + "EXPR [ (1, _279, _281) (1, _282) -1 ]", + "EXPR [ (1, _279, _282) 0 ]", + "EXPR [ (-2, _277, _279) (65536, _277) (1, _279) (-1, _283) 0 ]", + "EXPR [ (-1, _282) (-1, _284) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _280) 0 ]], outputs: [_285]", + "EXPR [ (1, _280, _285) (1, _286) -1 ]", + "EXPR [ (1, _280, _286) 0 ]", + "EXPR [ (-2, _277, _280) (65536, _277) (1, _280) (-1, _287) 0 ]", + "EXPR [ (-1, _286) (-1, _288) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _273, _271) (1, _283, _284) (1, _271) (1, _273) 131071 ], EXPR [ 65536 ]], outputs: [_289, _290]", + "BLACKBOX::RANGE [(_289, 2)] []", + "EXPR [ (-2, _271, _273) (1, _283, _284) (1, _271) (1, _273) (-65536, _289) (-1, _290) 131071 ]", + "EXPR [ (1, _290) -65439 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _276) 0 ], EXPR [ 32768 ]], outputs: [_291, _292]", + "BLACKBOX::RANGE [(_291, 1)] []", + "BLACKBOX::RANGE [(_292, 15)] []", + "EXPR [ (1, _276) (-32768, _291) (-1, _292) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _276, _291) (1, _276) (65536, _291) 0 ], EXPR [ 16384 ]], outputs: [_293, _294]", + "BLACKBOX::RANGE [(_293, 2)] []", + "BLACKBOX::RANGE [(_294, 14)] []", + "EXPR [ (-2, _276, _291) (1, _276) (65536, _291) (-16384, _293) (-1, _294) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _293) 0 ]], outputs: [_295]", + "EXPR [ (1, _293, _295) (1, _296) -1 ]", + "EXPR [ (1, _293, _296) 0 ]", + "EXPR [ (-2, _291, _293) (65536, _291) (1, _293) (-1, _297) 0 ]", + "EXPR [ (-1, _296) (-1, _298) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _294) 0 ]], outputs: [_299]", + "EXPR [ (1, _294, _299) (1, _300) -1 ]", + "EXPR [ (1, _294, _300) 0 ]", + "EXPR [ (-2, _291, _294) (65536, _291) (1, _294) (-1, _301) 0 ]", + "EXPR [ (-1, _300) (-1, _302) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _273, _271) (1, _297, _298) (1, _271) (1, _273) 131071 ], EXPR [ 65536 ]], outputs: [_303, _304]", + "BLACKBOX::RANGE [(_303, 2)] []", + "EXPR [ (-2, _271, _273) (1, _297, _298) (1, _271) (1, _273) (-65536, _303) (-1, _304) 131071 ]", + "EXPR [ (1, _304) -65535 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 65536 ]], outputs: [_305, _306]", + "BLACKBOX::RANGE [(_305, 48)] []", + "BLACKBOX::RANGE [(_306, 16)] []", + "EXPR [ (1, _0) (-65536, _305) (-1, _306) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _306) 0 ], EXPR [ 32768 ]], outputs: [_307, _308]", + "BLACKBOX::RANGE [(_307, 1)] []", + "BLACKBOX::RANGE [(_308, 15)] []", + "EXPR [ (1, _306) (-32768, _307) (-1, _308) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _306) 131086 ], EXPR [ 131072 ]], outputs: [_309, _310]", + "BLACKBOX::RANGE [(_309, 1)] []", + "BLACKBOX::RANGE [(_310, 17)] []", + "EXPR [ (-1, _306) (-131072, _309) (-1, _310) 131086 ]", + "EXPR [ (-2, _307, _309) (1, _307) (1, _309) (-1, _311) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (28, _309, _307) (1, _311, _306) (-14, _307) (-14, _309) 65535 ], EXPR [ 65536 ]], outputs: [_312, _313]", "BLACKBOX::RANGE [(_313, 16)] []", - "BLACKBOX::RANGE [(_314, 16)] []", - "EXPR [ (1, _312) (-1, _314) (-1, _315) -1 ]", - "BLACKBOX::RANGE [(_315, 16)] []", - "EXPR [ (-2, _305, _308) (-1, _312, _313) (1, _305) (65536, _308) (-1, _314) 0 ]", - "EXPR [ (-1, _313) (-1, _316) 32768 ]", - "EXPR [ (-2, _306, _308) (1, _306) (1, _308) (-1, _317) 0 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _313) 0 ]], outputs: [_318]", - "EXPR [ (1, _313, _318) (1, _319) -1 ]", - "EXPR [ (1, _313, _319) 0 ]", - "EXPR [ (2, _316, _317) (1, _313) (-1, _320) 0 ]", - "EXPR [ (-1, _319) (-1, _321) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _314) 0 ]], outputs: [_322]", - "EXPR [ (1, _314, _322) (1, _323) -1 ]", - "EXPR [ (1, _314, _323) 0 ]", - "EXPR [ (-2, _308, _314) (65536, _308) (1, _314) (-1, _324) 0 ]", - "EXPR [ (-1, _323) (-1, _325) 1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _302, _300) (1, _320, _321) (1, _300) (1, _302) 131071 ], EXPR [ 65536 ]], outputs: [_326, _327]", - "BLACKBOX::RANGE [(_326, 2)] []", - "BLACKBOX::RANGE [(_327, 16)] []", - "EXPR [ (-2, _300, _302) (1, _320, _321) (1, _300) (1, _302) (-65536, _326) (-1, _327) 131071 ]", - "EXPR [ (131070, _300, _302) (-65535, _300) (-65535, _302) (-1, _328) 65535 ]", - "EXPR [ (-1, _120, _327) (1, _120, _328) (1, _327) 0 ]", + "EXPR [ (1, _306, _311) (28, _307, _309) (-14, _307) (-14, _309) (-65536, _312) (-1, _313) 65535 ]", + "EXPR [ (-1, _312) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (28, _309, _307) (1, _311, _306) (-14, _307) (-14, _309) 14 ], EXPR [ 32768 ]], outputs: [_314, _315]", + "BLACKBOX::RANGE [(_314, 1)] []", + "BLACKBOX::RANGE [(_315, 15)] []", + "EXPR [ (1, _306, _311) (28, _307, _309) (-14, _307) (-14, _309) (-32768, _314) (-1, _315) 14 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (28, _309, _307) (1, _311, _306) (-14, _307) (-14, _309) 131070 ], EXPR [ 131072 ]], outputs: [_316, _317]", + "BLACKBOX::RANGE [(_316, 1)] []", + "BLACKBOX::RANGE [(_317, 17)] []", + "EXPR [ (1, _306, _311) (28, _307, _309) (-14, _307) (-14, _309) (-131072, _316) (-1, _317) 131070 ]", + "EXPR [ (2, _314, _316) (-1, _314) (-1, _316) (-1, _318) 1 ]", + "EXPR [ (1, _306, _311) (28, _307, _309) (-14, _307) (-14, _309) (-1, _319) 14 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _318, _319) 0 ], EXPR [ 5 ], EXPR [ 2 ]], outputs: [[_320, _321, _322, _323, _324]]", + "BLACKBOX::RANGE [(_320, 1)] []", + "BLACKBOX::RANGE [(_321, 1)] []", + "BLACKBOX::RANGE [(_322, 1)] []", + "BLACKBOX::RANGE [(_323, 1)] []", + "BLACKBOX::RANGE [(_324, 1)] []", + "EXPR [ (1, _318, _319) (-1, _320) (-2, _321) (-4, _322) (-8, _323) (-16, _324) 0 ]", + "EXPR [ (1, _324, _324) (2, _324) (-1, _325) 1 ]", + "EXPR [ (-1, _323) (-1, _326) 1 ]", + "EXPR [ (2, _323, _325) (1, _325, _326) (-1, _327) 0 ]", + "EXPR [ (1, _327, _327) (-1, _328) 0 ]", + "EXPR [ (-1, _322) (-1, _329) 1 ]", + "EXPR [ (2, _322, _328) (1, _328, _329) (-1, _330) 0 ]", + "EXPR [ (1, _330, _330) (-1, _331) 0 ]", + "EXPR [ (-1, _321) (-1, _332) 1 ]", + "EXPR [ (2, _321, _331) (1, _331, _332) (-1, _333) 0 ]", + "EXPR [ (1, _333, _333) (-1, _334) 0 ]", + "EXPR [ (-1, _320) (-1, _335) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _334, _320) (1, _334, _335) 0 ], EXPR [ 32768 ]], outputs: [_336, _337]", + "BLACKBOX::RANGE [(_336, 1)] []", + "BLACKBOX::RANGE [(_337, 15)] []", + "EXPR [ (2, _320, _334) (-1, _488) 0 ]", + "EXPR [ (1, _334, _335) (-1, _489) 0 ]", + "EXPR [ (-32768, _336) (-1, _337) (1, _488) (1, _489) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _276) 0 ], EXPR [ 32768 ]], outputs: [_338, _339]", + "BLACKBOX::RANGE [(_338, 1)] []", + "BLACKBOX::RANGE [(_339, 15)] []", + "EXPR [ (1, _276) (-32768, _338) (-1, _339) 0 ]", + "EXPR [ (-1, _340) (-1, _488) (-1, _489) 32768 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _334, _320) (1, _334, _335) (2, _340, _336) 0 ]], outputs: [_341]", + "EXPR [ (2, _336, _340) (-1, _342) (1, _488) (1, _489) 0 ]", + "EXPR [ (1, _341, _342) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _276, _338) (1, _276) (65536, _338) 0 ], EXPR [ (1, _342) 0 ]], outputs: [_343, _344]", + "BLACKBOX::RANGE [(_343, 16)] []", + "BLACKBOX::RANGE [(_344, 16)] []", + "EXPR [ (1, _342) (-1, _344) (-1, _345) -1 ]", + "BLACKBOX::RANGE [(_345, 16)] []", + "EXPR [ (-2, _276, _338) (-1, _342, _343) (1, _276) (65536, _338) (-1, _344) 0 ]", + "EXPR [ (-1, _343) (-1, _346) 32768 ]", + "EXPR [ (-2, _336, _338) (1, _336) (1, _338) (-1, _347) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _343) 0 ]], outputs: [_348]", + "EXPR [ (1, _343, _348) (1, _349) -1 ]", + "EXPR [ (1, _343, _349) 0 ]", + "EXPR [ (2, _346, _347) (1, _343) (-1, _350) 0 ]", + "EXPR [ (-1, _349) (-1, _351) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _344) 0 ]], outputs: [_352]", + "EXPR [ (1, _344, _352) (1, _353) -1 ]", + "EXPR [ (1, _344, _353) 0 ]", + "EXPR [ (-2, _338, _344) (65536, _338) (1, _344) (-1, _354) 0 ]", + "EXPR [ (-1, _353) (-1, _355) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _273, _271) (1, _350, _351) (1, _271) (1, _273) 131071 ], EXPR [ 65536 ]], outputs: [_356, _357]", + "BLACKBOX::RANGE [(_356, 2)] []", + "BLACKBOX::RANGE [(_357, 16)] []", + "EXPR [ (-2, _271, _273) (1, _350, _351) (1, _271) (1, _273) (-65536, _356) (-1, _357) 131071 ]", + "EXPR [ (131070, _271, _273) (-65535, _271) (-65535, _273) (-1, _358) 65535 ]", + "EXPR [ (-1, _318) (-1, _359) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _318, _357) (1, _358, _359) 0 ], EXPR [ 65536 ]], outputs: [_360, _361]", + "BLACKBOX::RANGE [(_360, 1)] []", + "EXPR [ (1, _318, _357) (1, _358, _359) (-65536, _360) (-1, _361) 0 ]", + "EXPR [ (1, _361) -65535 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _2) 131072 ], EXPR [ 65536 ]], outputs: [_362, _363]", + "BLACKBOX::RANGE [(_362, 2)] []", + "BLACKBOX::RANGE [(_363, 16)] []", + "EXPR [ (-1, _2) (-65536, _362) (-1, _363) 131072 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 32768 ], EXPR [ 65536 ]], outputs: [_364, _365]", + "BLACKBOX::RANGE [(_364, 1)] []", + "BLACKBOX::RANGE [(_365, 16)] []", + "EXPR [ (1, _2) (-65536, _364) (-1, _365) 32768 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _363) 32768 ], EXPR [ 65536 ]], outputs: [_366, _367]", + "BLACKBOX::RANGE [(_366, 1)] []", + "BLACKBOX::RANGE [(_367, 16)] []", + "EXPR [ (1, _363) (-65536, _366) (-1, _367) 32768 ]", + "EXPR [ (-1, _364, _366) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _363) 0 ], EXPR [ 32768 ]], outputs: [_368, _369]", + "BLACKBOX::RANGE [(_368, 1)] []", + "BLACKBOX::RANGE [(_369, 15)] []", + "EXPR [ (1, _363) (-32768, _368) (-1, _369) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _363) 131072 ], EXPR [ 131072 ]], outputs: [_370, _371]", + "BLACKBOX::RANGE [(_370, 1)] []", + "BLACKBOX::RANGE [(_371, 17)] []", + "EXPR [ (1, _363) (-131072, _370) (-1, _371) 131072 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _370, _368) (1, _363) (-1, _368) (-1, _370) 1 ], EXPR [ 65536 ]], outputs: [_372, _373]", + "BLACKBOX::RANGE [(_372, 1)] []", + "BLACKBOX::RANGE [(_373, 16)] []", + "EXPR [ (2, _368, _370) (1, _363) (-1, _368) (-1, _370) (-65536, _372) (-1, _373) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _334, _320) (1, _334, _335) 0 ], EXPR [ 32768 ]], outputs: [_374, _375]", + "BLACKBOX::RANGE [(_374, 1)] []", + "BLACKBOX::RANGE [(_375, 15)] []", + "EXPR [ (-32768, _374) (-1, _375) (1, _488) (1, _489) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _373) 0 ], EXPR [ 32768 ]], outputs: [_376, _377]", + "BLACKBOX::RANGE [(_376, 1)] []", + "BLACKBOX::RANGE [(_377, 15)] []", + "EXPR [ (1, _373) (-32768, _376) (-1, _377) 0 ]", + "EXPR [ (-1, _378) (-1, _488) (-1, _489) 32768 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (2, _334, _320) (1, _334, _335) (2, _378, _374) 0 ]], outputs: [_379]", + "EXPR [ (2, _374, _378) (-1, _380) (1, _488) (1, _489) 0 ]", + "EXPR [ (1, _379, _380) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _373, _376) (1, _373) (65536, _376) 0 ], EXPR [ (1, _380) 0 ]], outputs: [_381, _382]", + "BLACKBOX::RANGE [(_381, 16)] []", + "BLACKBOX::RANGE [(_382, 16)] []", + "EXPR [ (1, _380) (-1, _382) (-1, _383) -1 ]", + "BLACKBOX::RANGE [(_383, 16)] []", + "EXPR [ (-2, _373, _376) (-1, _380, _381) (1, _373) (65536, _376) (-1, _382) 0 ]", + "EXPR [ (-1, _381) (-1, _384) 32768 ]", + "EXPR [ (-2, _374, _376) (1, _374) (1, _376) (-1, _385) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _381) 0 ]], outputs: [_386]", + "EXPR [ (1, _381, _386) (1, _387) -1 ]", + "EXPR [ (1, _381, _387) 0 ]", + "EXPR [ (2, _384, _385) (1, _381) (-1, _388) 0 ]", + "EXPR [ (-1, _387) (-1, _389) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _382) 0 ]], outputs: [_390]", + "EXPR [ (1, _382, _390) (1, _391) -1 ]", + "EXPR [ (1, _382, _391) 0 ]", + "EXPR [ (-2, _376, _382) (65536, _376) (1, _382) (-1, _392) 0 ]", + "EXPR [ (-1, _391) (-1, _393) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _370, _368) (1, _388, _389) (1, _368) (1, _370) 131071 ], EXPR [ 65536 ]], outputs: [_394, _395]", + "BLACKBOX::RANGE [(_394, 2)] []", + "BLACKBOX::RANGE [(_395, 16)] []", + "EXPR [ (-2, _368, _370) (1, _388, _389) (1, _368) (1, _370) (-65536, _394) (-1, _395) 131071 ]", + "EXPR [ (131070, _368, _370) (-65535, _368) (-65535, _370) (-1, _396) 65535 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _318, _395) (1, _396, _359) 0 ], EXPR [ 65536 ]], outputs: [_397, _398]", + "BLACKBOX::RANGE [(_397, 1)] []", + "EXPR [ (1, _318, _395) (1, _359, _396) (-65536, _397) (-1, _398) 0 ]", + "EXPR [ (1, _398) 0 ]", "unconstrained func 0", "[Const { destination: Direct(10), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(11), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(10), offset_address: Direct(11) }, BinaryFieldOp { destination: Direct(2), op: IntegerDiv, lhs: Direct(0), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Mul, lhs: Direct(2), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Sub, lhs: Direct(0), rhs: Direct(1) }, Mov { destination: Direct(0), source: Direct(2) }, Stop { return_data: HeapVector { pointer: Direct(11), size: Direct(10) } }]", "unconstrained func 1", @@ -574,10 +707,10 @@ expression: artifact "unconstrained func 2", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "pdnLThtJFIDhd/GaRZ9b1al5ldEocogTIVmAHIg0ivLu09Wn/1wWs2lvfH5wzhcwLmPs76dPl4/vXz48PX9++Xr66+/vp4+3p+v16cuH68vj+e3p5Xn97PcfDyc+/PB2u1zWT51+u37dej3fLs9vp7+e36/Xh9O38/V9+0dfX8/P23w739Zrl4fT5fnTOlfw89P1MuvHw6/t5f9XZbF9WeTXehza70f2Tdi3vG/f/cj+yH1flzv3RQ7sqwb7du/+kdvf1Pd9O/T/m+TPfb1z/8jP30LZb+2+/X7k63fj9nM/cvt54/x4P3L+PH/u57hvfxy5/4Rw/kLu3Fc7sm+dfb93/8jtF40H32hH7j/ROb+Rcuf+ka+//Xz8bsud+xJH9o3brx16/P59/9DX3/j5t2537h95/GqD268vRx6/uvL9d9X79s3u3P/z+/9n/ej8+HT74xnPyddfmQ+n2C7bdtm3y9wux3YpSw2poTWsRgFSghQhZUghUoqWoqVoKVqKlqKlaClaipaipVgpVoqVYqVYKVaKlWKlWClWipfipXgpXoqX4qV4KV6Kl+KlRCmxKusvrViV9b4TVsNrRI1Wo9fIGquy/rJqq7I+ZjSpoTWshteIGq1Gr5E1xjZ6Kb2UXkovpZfSV6WtY1XWM9J7jawxtpFLDamhNVZlfVKQqzLWETVajV5j3i7rHS9HzbHsU/ap+7R9+j5jn22ffZ+7N3ZPloUQQgkjnAiiEZ1IAlmQBVmQBVmQBVmQBVmQBVmRFVmRFVmRFVmRFVmRFdmQDdmQDdmQDdmQDdmQDdmRHdmRHdmRHdmRHdmRHTmQAzmQAzmQAzmQAzmQA7khN+SG3JAbckNuyA25ITfkjjyPlWwPbFPWGUY4EUQjOpHE2GMetAohkBM5kRM5kRM5kRN5IA/kgTyQB/JAHsgDeSCPXdZlIYRQwggngmhEJ5JAFmRBFmRBFmRBFmRBFmRBVmRFVmRFVmRFVmRFVmRFNmRDNmRDNmRDNmRDNmRDdmRHdmRHdmRHdmRHdmRHDuRADuRADuTtDNqMKbcZnUhi7LGdwS2EUGLKfcaUc0YQjehEEmOP7QxuIYQSRiB35I7ckTtyR07kRE7kRE7kRE7kRE7kRB7IA3kgD+SBPJAH8nYGx4ycL4PMGBU2z2CFEEoY4UQQjehEEsiCLMiCLMiCLMiCLMiCLMiKrMiKrMiKrMiKrMiKrMiGbMiGbMiGbMiGbMiGbMiO7MiO7MiO7MiO7MiO7MiBHMiBHMiBHMiBHMiBHMgNuSE35IbckBtyQ27I8wzq9gR6yjqfQi+EEEoY4UQQjehEEsiJnMjzDKrNMMKJIBrRiSSm7POJ/pRjhhBKGOFEEI3oRBKjwpeFEEIJI5wIYsptxpT7jCTGHtsZ3EIIJYxwIogp54wpjxlJjD22M7iFEEoY4UQQjUBWZEU2ZEM2ZEM2ZEM2ZEOeZ3C+duDzDNr2d9gyXw6dIYQSRjgRRCM6kcTYI5ADOZC3P99shhNBNKITSYw95hmsEEIJ5IbckBtyQ27IDbkjd+SO3JE7ckfuyB25I3fkRE7kRE7kRE7kRE7kRE7kgTyQB/JAHsgDeSAP5IE8djnmGbT5+tS38+3p/PF6+Vpv33x+f3787d2ct39fuYb3e15vL4+XT++3y3wdZLtufWXkPw==", + "debug_symbols": "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", "file_map": { "50": { - "source": "fn main(x: u64, y: u8, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176, superseded by issue #8791\n assert(u >> (x as u8) == -1);\n assert(z >> (x as u8) == -1);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n\n assert(z >> 16 == -1);\n assert(-z >> x as u8 == 0);\n}\n", + "source": "fn main(x: u64, y: u64, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176, superseded by issue #8791\n assert(u >> (x as i64 - 2) == -1);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> a == 32);\n a = -a;\n assert(a << 6 == -64);\n assert(a << -a == -2);\n\n assert(x >> (x - 1) == 0);\n\n assert_eq(z >> 3, -97);\n\n assert(z >> 14 == -1);\n let rhs = (if x as i16 > 14 { 14 } else { x as i16 });\n assert(z >> rhs == -1);\n assert(-z >> rhs == 0);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 267c78de544..ff0ca849d90 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -21,7 +21,7 @@ expression: artifact "type": { "kind": "integer", "sign": "unsigned", - "width": 8 + "width": 64 }, "visibility": "private" }, @@ -68,12 +68,12 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ], EXPR [ (1, _2) 0 ], EXPR [ (1, _3) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32840 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U64) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U8) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U16) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U64) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Mov { destination: Relative(3), source: Direct(32838) }, Mov { destination: Relative(4), source: Direct(32839) }, Call { location: 19 }, Call { location: 20 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 525 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 64 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(8), location: 28 }, Call { location: 531 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 128 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 33 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, BinaryIntOp { destination: Relative(6), op: Shr, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(8), location: 39 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 64 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 44 }, Call { location: 531 }, Const { destination: Relative(6), bit_size: Integer(U64), value: 128 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 49 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(5), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U64), value: 32 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 55 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Cast { destination: Relative(6), source: Relative(1), bit_size: Integer(U8) }, Cast { destination: Relative(5), source: Relative(6), bit_size: Integer(U64) }, Cast { destination: Relative(6), source: Relative(5), bit_size: Integer(U8) }, Const { destination: Relative(10), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U64, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 62 }, Jump { location: 109 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 64 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(12) }, JumpIf { condition: Relative(11), location: 66 }, Jump { location: 106 }, Const { destination: Relative(13), bit_size: Integer(U64), value: 1 }, Const { destination: Relative(14), bit_size: Integer(U64), value: 2 }, Const { destination: Relative(15), bit_size: Integer(U64), value: 1 }, Cast { destination: Relative(16), source: Relative(6), bit_size: Integer(U32) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Relative(16) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 77 }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Jump { location: 71 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(13) }, Const { destination: Relative(22), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U64, lhs: Relative(22), rhs: Relative(8) }, Const { destination: Relative(23), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(24), op: Sub, bit_size: U64, lhs: Relative(23), rhs: Relative(8) }, JumpIf { condition: Relative(17), location: 84 }, Jump { location: 86 }, Mov { destination: Relative(18), source: Relative(24) }, Jump { location: 88 }, Mov { destination: Relative(18), source: Relative(8) }, Jump { location: 88 }, Const { destination: Relative(22), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U64, lhs: Relative(22), rhs: Relative(15) }, Const { destination: Relative(23), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(24), op: Sub, bit_size: U64, lhs: Relative(23), rhs: Relative(15) }, JumpIf { condition: Relative(19), location: 94 }, Jump { location: 96 }, Mov { destination: Relative(20), source: Relative(24) }, Jump { location: 98 }, Mov { destination: Relative(20), source: Relative(15) }, Jump { location: 98 }, BinaryIntOp { destination: Relative(8), op: Div, bit_size: U64, lhs: Relative(18), rhs: Relative(20) }, BinaryIntOp { destination: Relative(21), op: Xor, bit_size: U1, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(21), location: 102 }, Jump { location: 104 }, Const { destination: Relative(22), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U64, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U64, lhs: Relative(8), rhs: Relative(13) }, Jump { location: 108 }, Const { destination: Relative(8), bit_size: Integer(U64), value: 18446744073709551615 }, Jump { location: 108 }, Jump { location: 111 }, BinaryIntOp { destination: Relative(8), op: Shr, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, Jump { location: 111 }, Const { destination: Relative(4), bit_size: Integer(U64), value: 18446744073709551615 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U64, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 116 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, Const { destination: Relative(9), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U16, lhs: Relative(9), rhs: Relative(3) }, JumpIf { condition: Relative(8), location: 120 }, Jump { location: 167 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(13) }, JumpIf { condition: Relative(11), location: 124 }, Jump { location: 164 }, Const { destination: Relative(14), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(15), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(16), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(17), source: Relative(6), bit_size: Integer(U32) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(17) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 135 }, BinaryIntOp { destination: Relative(16), op: Mul, bit_size: U16, lhs: Relative(16), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Jump { location: 129 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(14) }, Const { destination: Relative(23), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U16, lhs: Relative(23), rhs: Relative(4) }, Const { destination: Relative(24), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(25), op: Sub, bit_size: U16, lhs: Relative(24), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 142 }, Jump { location: 144 }, Mov { destination: Relative(19), source: Relative(25) }, Jump { location: 146 }, Mov { destination: Relative(19), source: Relative(4) }, Jump { location: 146 }, Const { destination: Relative(23), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U16, lhs: Relative(23), rhs: Relative(16) }, Const { destination: Relative(24), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(25), op: Sub, bit_size: U16, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(20), location: 152 }, Jump { location: 154 }, Mov { destination: Relative(21), source: Relative(25) }, Jump { location: 156 }, Mov { destination: Relative(21), source: Relative(16) }, Jump { location: 156 }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U16, lhs: Relative(19), rhs: Relative(21) }, BinaryIntOp { destination: Relative(22), op: Xor, bit_size: U1, lhs: Relative(18), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 160 }, Jump { location: 162 }, Const { destination: Relative(23), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(23), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(4), rhs: Relative(14) }, Jump { location: 166 }, Const { destination: Relative(4), bit_size: Integer(U16), value: 65535 }, Jump { location: 166 }, Jump { location: 169 }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(6) }, Jump { location: 169 }, Const { destination: Relative(8), bit_size: Integer(U16), value: 65535 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U16, lhs: Relative(4), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Cast { destination: Relative(4), source: Relative(2), bit_size: Integer(U8) }, Cast { destination: Relative(11), source: Relative(5), bit_size: Integer(U8) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(14), op: Shl, bit_size: U8, lhs: Relative(11), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(14) }, Const { destination: Relative(14), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(14) }, JumpIf { condition: Relative(15), location: 184 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Const { destination: Relative(5), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U8, lhs: Relative(17), rhs: Relative(11) }, JumpIf { condition: Relative(16), location: 189 }, Jump { location: 236 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U8, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(18), location: 193 }, Jump { location: 233 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 1 }, Cast { destination: Relative(23), source: Relative(5), bit_size: Integer(U32) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U32, lhs: Relative(24), rhs: Relative(23) }, Not { destination: Relative(25), source: Relative(25), bit_size: U1 }, JumpIf { condition: Relative(25), location: 204 }, BinaryIntOp { destination: Relative(22), op: Mul, bit_size: U8, lhs: Relative(22), rhs: Relative(21) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Jump { location: 198 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U8, lhs: Relative(11), rhs: Relative(20) }, Const { destination: Relative(29), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U8, lhs: Relative(29), rhs: Relative(15) }, Const { destination: Relative(30), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(31), op: Sub, bit_size: U8, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(24), location: 211 }, Jump { location: 213 }, Mov { destination: Relative(25), source: Relative(31) }, Jump { location: 215 }, Mov { destination: Relative(25), source: Relative(15) }, Jump { location: 215 }, Const { destination: Relative(29), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U8, lhs: Relative(29), rhs: Relative(22) }, Const { destination: Relative(30), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(31), op: Sub, bit_size: U8, lhs: Relative(30), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 221 }, Jump { location: 223 }, Mov { destination: Relative(27), source: Relative(31) }, Jump { location: 225 }, Mov { destination: Relative(27), source: Relative(22) }, Jump { location: 225 }, BinaryIntOp { destination: Relative(15), op: Div, bit_size: U8, lhs: Relative(25), rhs: Relative(27) }, BinaryIntOp { destination: Relative(28), op: Xor, bit_size: U1, lhs: Relative(24), rhs: Relative(26) }, JumpIf { condition: Relative(28), location: 229 }, Jump { location: 231 }, Const { destination: Relative(29), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U8, lhs: Relative(29), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U8, lhs: Relative(15), rhs: Relative(20) }, Jump { location: 235 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 255 }, Jump { location: 235 }, Jump { location: 238 }, BinaryIntOp { destination: Relative(15), op: Shr, bit_size: U8, lhs: Relative(11), rhs: Relative(5) }, Jump { location: 238 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U8, lhs: Relative(15), rhs: Relative(5) }, JumpIf { condition: Relative(16), location: 243 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(16), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U8, lhs: Relative(16), rhs: Relative(11) }, JumpIf { condition: Relative(15), location: 247 }, Jump { location: 294 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 251 }, Jump { location: 291 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 1 }, Cast { destination: Relative(24), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(25), rhs: Relative(24) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 262 }, BinaryIntOp { destination: Relative(23), op: Mul, bit_size: U8, lhs: Relative(23), rhs: Relative(22) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Jump { location: 256 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U8, lhs: Relative(11), rhs: Relative(21) }, Const { destination: Relative(30), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U8, lhs: Relative(30), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U8, lhs: Relative(31), rhs: Relative(5) }, JumpIf { condition: Relative(25), location: 269 }, Jump { location: 271 }, Mov { destination: Relative(26), source: Relative(32) }, Jump { location: 273 }, Mov { destination: Relative(26), source: Relative(5) }, Jump { location: 273 }, Const { destination: Relative(30), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U8, lhs: Relative(30), rhs: Relative(23) }, Const { destination: Relative(31), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U8, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(27), location: 279 }, Jump { location: 281 }, Mov { destination: Relative(28), source: Relative(32) }, Jump { location: 283 }, Mov { destination: Relative(28), source: Relative(23) }, Jump { location: 283 }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U8, lhs: Relative(26), rhs: Relative(28) }, BinaryIntOp { destination: Relative(29), op: Xor, bit_size: U1, lhs: Relative(25), rhs: Relative(27) }, JumpIf { condition: Relative(29), location: 287 }, Jump { location: 289 }, Const { destination: Relative(30), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U8, lhs: Relative(30), rhs: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U8, lhs: Relative(5), rhs: Relative(21) }, Jump { location: 293 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 255 }, Jump { location: 293 }, Jump { location: 296 }, BinaryIntOp { destination: Relative(5), op: Shr, bit_size: U8, lhs: Relative(11), rhs: Relative(2) }, Jump { location: 296 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(15), location: 301 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(5), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U8, lhs: Relative(5), rhs: Relative(4) }, Mov { destination: Relative(4), source: Relative(11) }, Cast { destination: Relative(5), source: Relative(4), bit_size: Integer(U8) }, Const { destination: Relative(11), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(11) }, Not { destination: Relative(18), source: Relative(15), bit_size: U1 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U8, lhs: Relative(5), rhs: Relative(11) }, BinaryIntOp { destination: Relative(5), op: Mul, bit_size: U1, lhs: Relative(15), rhs: Relative(18) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U1, lhs: Relative(5), rhs: Relative(18) }, JumpIf { condition: Relative(11), location: 313 }, Call { location: 534 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 7 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U8, lhs: Relative(4), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(14) }, JumpIf { condition: Relative(11), location: 320 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U8, lhs: Relative(4), rhs: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(11), location: 325 }, Call { location: 531 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 254 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U8, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 331 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 337 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U16, lhs: Relative(5), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 342 }, Jump { location: 389 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U8, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(7), location: 346 }, Jump { location: 386 }, Const { destination: Relative(14), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(15), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(18), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(21), source: Relative(1), bit_size: Integer(U32) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 357 }, BinaryIntOp { destination: Relative(18), op: Mul, bit_size: U16, lhs: Relative(18), rhs: Relative(15) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Jump { location: 351 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(14) }, Const { destination: Relative(27), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U16, lhs: Relative(27), rhs: Relative(2) }, Const { destination: Relative(28), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U16, lhs: Relative(28), rhs: Relative(2) }, JumpIf { condition: Relative(22), location: 364 }, Jump { location: 366 }, Mov { destination: Relative(23), source: Relative(29) }, Jump { location: 368 }, Mov { destination: Relative(23), source: Relative(2) }, Jump { location: 368 }, Const { destination: Relative(27), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U16, lhs: Relative(27), rhs: Relative(18) }, Const { destination: Relative(28), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U16, lhs: Relative(28), rhs: Relative(18) }, JumpIf { condition: Relative(24), location: 374 }, Jump { location: 376 }, Mov { destination: Relative(25), source: Relative(29) }, Jump { location: 378 }, Mov { destination: Relative(25), source: Relative(18) }, Jump { location: 378 }, BinaryIntOp { destination: Relative(2), op: Div, bit_size: U16, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(26), op: Xor, bit_size: U1, lhs: Relative(22), rhs: Relative(24) }, JumpIf { condition: Relative(26), location: 382 }, Jump { location: 384 }, Const { destination: Relative(27), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(27), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(2), rhs: Relative(14) }, Jump { location: 388 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65535 }, Jump { location: 388 }, Jump { location: 391 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, Jump { location: 391 }, Const { destination: Relative(1), bit_size: Integer(U16), value: 65439 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 396 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 16 }, Const { destination: Relative(7), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U16, lhs: Relative(7), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 401 }, Jump { location: 448 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U8, lhs: Relative(1), rhs: Relative(15) }, JumpIf { condition: Relative(14), location: 405 }, Jump { location: 445 }, Const { destination: Relative(18), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(21), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(22), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(23), source: Relative(1), bit_size: Integer(U32) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U32, lhs: Relative(24), rhs: Relative(23) }, Not { destination: Relative(25), source: Relative(25), bit_size: U1 }, JumpIf { condition: Relative(25), location: 416 }, BinaryIntOp { destination: Relative(22), op: Mul, bit_size: U16, lhs: Relative(22), rhs: Relative(21) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Jump { location: 410 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(18) }, Const { destination: Relative(29), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U16, lhs: Relative(29), rhs: Relative(2) }, Const { destination: Relative(30), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(31), op: Sub, bit_size: U16, lhs: Relative(30), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 423 }, Jump { location: 425 }, Mov { destination: Relative(25), source: Relative(31) }, Jump { location: 427 }, Mov { destination: Relative(25), source: Relative(2) }, Jump { location: 427 }, Const { destination: Relative(29), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U16, lhs: Relative(29), rhs: Relative(22) }, Const { destination: Relative(30), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(31), op: Sub, bit_size: U16, lhs: Relative(30), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 433 }, Jump { location: 435 }, Mov { destination: Relative(27), source: Relative(31) }, Jump { location: 437 }, Mov { destination: Relative(27), source: Relative(22) }, Jump { location: 437 }, BinaryIntOp { destination: Relative(2), op: Div, bit_size: U16, lhs: Relative(25), rhs: Relative(27) }, BinaryIntOp { destination: Relative(28), op: Xor, bit_size: U1, lhs: Relative(24), rhs: Relative(26) }, JumpIf { condition: Relative(28), location: 441 }, Jump { location: 443 }, Const { destination: Relative(29), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(29), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(2), rhs: Relative(18) }, Jump { location: 447 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65535 }, Jump { location: 447 }, Jump { location: 450 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, Jump { location: 450 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(1), location: 454 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(1), rhs: Relative(3) }, Mov { destination: Relative(4), source: Relative(2) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Integer(U16) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Integer(U16) }, Const { destination: Relative(3), bit_size: Integer(U16), value: 32768 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U16, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(14), bit_size: U1 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U16, lhs: Relative(2), rhs: Relative(3) }, BinaryIntOp { destination: Relative(2), op: Mul, bit_size: U1, lhs: Relative(14), rhs: Relative(8) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(3), location: 467 }, Call { location: 534 }, Const { destination: Relative(8), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U16, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(3), location: 471 }, Jump { location: 518 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(18) }, JumpIf { condition: Relative(14), location: 475 }, Jump { location: 515 }, Const { destination: Relative(21), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(22), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(23), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(24), source: Relative(6), bit_size: Integer(U32) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(25), rhs: Relative(24) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 486 }, BinaryIntOp { destination: Relative(23), op: Mul, bit_size: U16, lhs: Relative(23), rhs: Relative(22) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Jump { location: 480 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U16, lhs: Relative(4), rhs: Relative(21) }, Const { destination: Relative(30), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U16, lhs: Relative(30), rhs: Relative(2) }, Const { destination: Relative(31), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U16, lhs: Relative(31), rhs: Relative(2) }, JumpIf { condition: Relative(25), location: 493 }, Jump { location: 495 }, Mov { destination: Relative(26), source: Relative(32) }, Jump { location: 497 }, Mov { destination: Relative(26), source: Relative(2) }, Jump { location: 497 }, Const { destination: Relative(30), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U16, lhs: Relative(30), rhs: Relative(23) }, Const { destination: Relative(31), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U16, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(27), location: 503 }, Jump { location: 505 }, Mov { destination: Relative(28), source: Relative(32) }, Jump { location: 507 }, Mov { destination: Relative(28), source: Relative(23) }, Jump { location: 507 }, BinaryIntOp { destination: Relative(2), op: Div, bit_size: U16, lhs: Relative(26), rhs: Relative(28) }, BinaryIntOp { destination: Relative(29), op: Xor, bit_size: U1, lhs: Relative(25), rhs: Relative(27) }, JumpIf { condition: Relative(29), location: 511 }, Jump { location: 513 }, Const { destination: Relative(30), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(30), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(2), rhs: Relative(21) }, Jump { location: 517 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65535 }, Jump { location: 517 }, Jump { location: 520 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(4), rhs: Relative(6) }, Jump { location: 520 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 524 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 530 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32840 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U64) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U64) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U16) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U64) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Mov { destination: Relative(3), source: Direct(32838) }, Mov { destination: Relative(4), source: Direct(32839) }, Call { location: 19 }, Call { location: 20 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 584 }, Const { destination: Relative(5), bit_size: Integer(U64), value: 64 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U64, lhs: Relative(2), rhs: Relative(5) }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 26 }, Call { location: 590 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U64), value: 128 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U64, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 32 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, BinaryIntOp { destination: Relative(6), op: Shr, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(9), bit_size: Integer(U64), value: 32 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U64, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(10), location: 38 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U64, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(10), location: 43 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, BinaryIntOp { destination: Relative(6), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U64, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(8), location: 48 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Cast { destination: Relative(6), source: Relative(1), bit_size: Integer(U64) }, Const { destination: Relative(8), bit_size: Integer(U64), value: 2 }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U64, lhs: Relative(6), rhs: Relative(8) }, Mov { destination: Relative(6), source: Relative(9) }, Cast { destination: Relative(8), source: Relative(6), bit_size: Integer(U64) }, Const { destination: Relative(9), bit_size: Integer(U64), value: 9223372036854775808 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U64, lhs: Relative(1), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(10), bit_size: U1 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U64, lhs: Relative(8), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(12), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U1, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(9), location: 62 }, Call { location: 593 }, Const { destination: Relative(9), bit_size: Integer(U64), value: 63 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U64, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(10), location: 66 }, Call { location: 590 }, Const { destination: Relative(10), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U64, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 70 }, Jump { location: 117 }, Const { destination: Relative(12), bit_size: Integer(U64), value: 64 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U64, lhs: Relative(6), rhs: Relative(12) }, JumpIf { condition: Relative(11), location: 74 }, Jump { location: 114 }, Const { destination: Relative(13), bit_size: Integer(U64), value: 1 }, Const { destination: Relative(14), bit_size: Integer(U64), value: 2 }, Const { destination: Relative(15), bit_size: Integer(U64), value: 1 }, Cast { destination: Relative(16), source: Relative(6), bit_size: Integer(U32) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Relative(16) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 85 }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Jump { location: 79 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(13) }, Const { destination: Relative(22), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U64, lhs: Relative(22), rhs: Relative(8) }, Const { destination: Relative(23), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(24), op: Sub, bit_size: U64, lhs: Relative(23), rhs: Relative(8) }, JumpIf { condition: Relative(17), location: 92 }, Jump { location: 94 }, Mov { destination: Relative(18), source: Relative(24) }, Jump { location: 96 }, Mov { destination: Relative(18), source: Relative(8) }, Jump { location: 96 }, Const { destination: Relative(22), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U64, lhs: Relative(22), rhs: Relative(15) }, Const { destination: Relative(23), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(24), op: Sub, bit_size: U64, lhs: Relative(23), rhs: Relative(15) }, JumpIf { condition: Relative(19), location: 102 }, Jump { location: 104 }, Mov { destination: Relative(20), source: Relative(24) }, Jump { location: 106 }, Mov { destination: Relative(20), source: Relative(15) }, Jump { location: 106 }, BinaryIntOp { destination: Relative(8), op: Div, bit_size: U64, lhs: Relative(18), rhs: Relative(20) }, BinaryIntOp { destination: Relative(21), op: Xor, bit_size: U1, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(21), location: 110 }, Jump { location: 112 }, Const { destination: Relative(22), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U64, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U64, lhs: Relative(8), rhs: Relative(13) }, Jump { location: 116 }, Const { destination: Relative(8), bit_size: Integer(U64), value: 18446744073709551615 }, Jump { location: 116 }, Jump { location: 119 }, BinaryIntOp { destination: Relative(8), op: Shr, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, Jump { location: 119 }, Mov { destination: Relative(4), source: Relative(8) }, Const { destination: Relative(6), bit_size: Integer(U64), value: 18446744073709551615 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 125 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Cast { destination: Relative(6), source: Relative(2), bit_size: Integer(U8) }, Cast { destination: Relative(4), source: Relative(6), bit_size: Integer(U64) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Integer(U8) }, Cast { destination: Relative(8), source: Relative(1), bit_size: Integer(U8) }, Cast { destination: Relative(6), source: Relative(8), bit_size: Integer(U64) }, Cast { destination: Relative(8), source: Relative(6), bit_size: Integer(U8) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(9), op: Shl, bit_size: U8, lhs: Relative(8), rhs: Relative(6) }, Mov { destination: Relative(6), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 139 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(6), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U8, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 144 }, Jump { location: 191 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(15) }, JumpIf { condition: Relative(14), location: 148 }, Jump { location: 188 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 1 }, Cast { destination: Relative(19), source: Relative(6), bit_size: Integer(U32) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(19) }, Not { destination: Relative(21), source: Relative(21), bit_size: U1 }, JumpIf { condition: Relative(21), location: 159 }, BinaryIntOp { destination: Relative(18), op: Mul, bit_size: U8, lhs: Relative(18), rhs: Relative(17) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Jump { location: 153 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U8, lhs: Relative(8), rhs: Relative(16) }, Const { destination: Relative(25), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U8, lhs: Relative(25), rhs: Relative(9) }, Const { destination: Relative(26), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(27), op: Sub, bit_size: U8, lhs: Relative(26), rhs: Relative(9) }, JumpIf { condition: Relative(20), location: 166 }, Jump { location: 168 }, Mov { destination: Relative(21), source: Relative(27) }, Jump { location: 170 }, Mov { destination: Relative(21), source: Relative(9) }, Jump { location: 170 }, Const { destination: Relative(25), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U8, lhs: Relative(25), rhs: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(27), op: Sub, bit_size: U8, lhs: Relative(26), rhs: Relative(18) }, JumpIf { condition: Relative(22), location: 176 }, Jump { location: 178 }, Mov { destination: Relative(23), source: Relative(27) }, Jump { location: 180 }, Mov { destination: Relative(23), source: Relative(18) }, Jump { location: 180 }, BinaryIntOp { destination: Relative(9), op: Div, bit_size: U8, lhs: Relative(21), rhs: Relative(23) }, BinaryIntOp { destination: Relative(24), op: Xor, bit_size: U1, lhs: Relative(20), rhs: Relative(22) }, JumpIf { condition: Relative(24), location: 184 }, Jump { location: 186 }, Const { destination: Relative(25), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U8, lhs: Relative(25), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U8, lhs: Relative(9), rhs: Relative(16) }, Jump { location: 190 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 255 }, Jump { location: 190 }, Jump { location: 193 }, BinaryIntOp { destination: Relative(9), op: Shr, bit_size: U8, lhs: Relative(8), rhs: Relative(6) }, Jump { location: 193 }, Mov { destination: Relative(6), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 199 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Cast { destination: Relative(6), source: Relative(4), bit_size: Integer(U8) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 7 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 204 }, Call { location: 590 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U8, lhs: Relative(14), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 208 }, Jump { location: 255 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(17) }, JumpIf { condition: Relative(16), location: 212 }, Jump { location: 252 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 1 }, Cast { destination: Relative(21), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 223 }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U8, lhs: Relative(20), rhs: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Jump { location: 217 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U8, lhs: Relative(8), rhs: Relative(18) }, Const { destination: Relative(27), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U8, lhs: Relative(27), rhs: Relative(9) }, Const { destination: Relative(28), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U8, lhs: Relative(28), rhs: Relative(9) }, JumpIf { condition: Relative(22), location: 230 }, Jump { location: 232 }, Mov { destination: Relative(23), source: Relative(29) }, Jump { location: 234 }, Mov { destination: Relative(23), source: Relative(9) }, Jump { location: 234 }, Const { destination: Relative(27), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U8, lhs: Relative(27), rhs: Relative(20) }, Const { destination: Relative(28), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U8, lhs: Relative(28), rhs: Relative(20) }, JumpIf { condition: Relative(24), location: 240 }, Jump { location: 242 }, Mov { destination: Relative(25), source: Relative(29) }, Jump { location: 244 }, Mov { destination: Relative(25), source: Relative(20) }, Jump { location: 244 }, BinaryIntOp { destination: Relative(9), op: Div, bit_size: U8, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(26), op: Xor, bit_size: U1, lhs: Relative(22), rhs: Relative(24) }, JumpIf { condition: Relative(26), location: 248 }, Jump { location: 250 }, Const { destination: Relative(27), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U8, lhs: Relative(27), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U8, lhs: Relative(9), rhs: Relative(18) }, Jump { location: 254 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 255 }, Jump { location: 254 }, Jump { location: 257 }, BinaryIntOp { destination: Relative(9), op: Shr, bit_size: U8, lhs: Relative(8), rhs: Relative(2) }, Jump { location: 257 }, Mov { destination: Relative(8), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 263 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Const { destination: Relative(8), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U8, lhs: Relative(8), rhs: Relative(2) }, Mov { destination: Relative(2), source: Relative(9) }, Cast { destination: Relative(9), source: Relative(2), bit_size: Integer(U8) }, Const { destination: Relative(11), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(11) }, Not { destination: Relative(6), source: Relative(16), bit_size: U1 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U8, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(9), op: Mul, bit_size: U1, lhs: Relative(16), rhs: Relative(6) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(6) }, JumpIf { condition: Relative(18), location: 275 }, Call { location: 593 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 6 }, BinaryIntOp { destination: Relative(9), op: Shl, bit_size: U8, lhs: Relative(2), rhs: Relative(6) }, Mov { destination: Relative(6), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U8), value: 192 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(18), location: 283 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U8, lhs: Relative(8), rhs: Relative(2) }, Mov { destination: Relative(8), source: Relative(6) }, Cast { destination: Relative(6), source: Relative(8), bit_size: Integer(U8) }, Not { destination: Relative(9), source: Relative(16), bit_size: U1 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Mul, bit_size: U1, lhs: Relative(16), rhs: Relative(9) }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U1, lhs: Relative(11), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 292 }, Call { location: 593 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 295 }, Call { location: 590 }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U8, lhs: Relative(2), rhs: Relative(8) }, Mov { destination: Relative(2), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 254 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U8, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 302 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(2), bit_size: Integer(U64), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 307 }, Call { location: 593 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(2), location: 310 }, Call { location: 590 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 316 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Const { destination: Relative(2), bit_size: Integer(U16), value: 3 }, Const { destination: Relative(6), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U16, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 321 }, Jump { location: 368 }, Const { destination: Relative(9), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U16, lhs: Relative(2), rhs: Relative(9) }, JumpIf { condition: Relative(8), location: 325 }, Jump { location: 365 }, Const { destination: Relative(11), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(16), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(18), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(19), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(19) }, Not { destination: Relative(21), source: Relative(21), bit_size: U1 }, JumpIf { condition: Relative(21), location: 336 }, BinaryIntOp { destination: Relative(18), op: Mul, bit_size: U16, lhs: Relative(18), rhs: Relative(16) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Jump { location: 330 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(11) }, Const { destination: Relative(25), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U16, lhs: Relative(25), rhs: Relative(4) }, Const { destination: Relative(26), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(27), op: Sub, bit_size: U16, lhs: Relative(26), rhs: Relative(4) }, JumpIf { condition: Relative(20), location: 343 }, Jump { location: 345 }, Mov { destination: Relative(21), source: Relative(27) }, Jump { location: 347 }, Mov { destination: Relative(21), source: Relative(4) }, Jump { location: 347 }, Const { destination: Relative(25), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U16, lhs: Relative(25), rhs: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(27), op: Sub, bit_size: U16, lhs: Relative(26), rhs: Relative(18) }, JumpIf { condition: Relative(22), location: 353 }, Jump { location: 355 }, Mov { destination: Relative(23), source: Relative(27) }, Jump { location: 357 }, Mov { destination: Relative(23), source: Relative(18) }, Jump { location: 357 }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U16, lhs: Relative(21), rhs: Relative(23) }, BinaryIntOp { destination: Relative(24), op: Xor, bit_size: U1, lhs: Relative(20), rhs: Relative(22) }, JumpIf { condition: Relative(24), location: 361 }, Jump { location: 363 }, Const { destination: Relative(25), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(25), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(4), rhs: Relative(11) }, Jump { location: 367 }, Const { destination: Relative(4), bit_size: Integer(U16), value: 65535 }, Jump { location: 367 }, Jump { location: 370 }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(2) }, Jump { location: 370 }, Mov { destination: Relative(2), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U16), value: 65439 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 376 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(2), bit_size: Integer(U16), value: 14 }, Const { destination: Relative(8), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U16, lhs: Relative(8), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 381 }, Jump { location: 428 }, Const { destination: Relative(16), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U16, lhs: Relative(2), rhs: Relative(16) }, JumpIf { condition: Relative(11), location: 385 }, Jump { location: 425 }, Const { destination: Relative(18), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(19), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(20), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(21), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 396 }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U16, lhs: Relative(20), rhs: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Jump { location: 390 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(18) }, Const { destination: Relative(27), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U16, lhs: Relative(27), rhs: Relative(4) }, Const { destination: Relative(28), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U16, lhs: Relative(28), rhs: Relative(4) }, JumpIf { condition: Relative(22), location: 403 }, Jump { location: 405 }, Mov { destination: Relative(23), source: Relative(29) }, Jump { location: 407 }, Mov { destination: Relative(23), source: Relative(4) }, Jump { location: 407 }, Const { destination: Relative(27), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U16, lhs: Relative(27), rhs: Relative(20) }, Const { destination: Relative(28), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U16, lhs: Relative(28), rhs: Relative(20) }, JumpIf { condition: Relative(24), location: 413 }, Jump { location: 415 }, Mov { destination: Relative(25), source: Relative(29) }, Jump { location: 417 }, Mov { destination: Relative(25), source: Relative(20) }, Jump { location: 417 }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U16, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(26), op: Xor, bit_size: U1, lhs: Relative(22), rhs: Relative(24) }, JumpIf { condition: Relative(26), location: 421 }, Jump { location: 423 }, Const { destination: Relative(27), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(27), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(4), rhs: Relative(18) }, Jump { location: 427 }, Const { destination: Relative(4), bit_size: Integer(U16), value: 65535 }, Jump { location: 427 }, Jump { location: 430 }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(2) }, Jump { location: 430 }, Mov { destination: Relative(5), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U16), value: 65535 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U16, lhs: Relative(5), rhs: Relative(4) }, JumpIf { condition: Relative(11), location: 436 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Cast { destination: Relative(11), source: Relative(1), bit_size: Integer(U16) }, Cast { destination: Relative(5), source: Relative(11), bit_size: Integer(U64) }, Cast { destination: Relative(1), source: Relative(5), bit_size: Integer(U16) }, Const { destination: Relative(19), bit_size: Integer(U16), value: 32768 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U16, lhs: Relative(2), rhs: Relative(19) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U16, lhs: Relative(1), rhs: Relative(19) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U16, lhs: Relative(11), rhs: Relative(18) }, Not { destination: Relative(11), source: Relative(5), bit_size: U1 }, Cast { destination: Relative(18), source: Relative(5), bit_size: Integer(U16) }, Cast { destination: Relative(5), source: Relative(11), bit_size: Integer(U16) }, BinaryIntOp { destination: Relative(11), op: Mul, bit_size: U16, lhs: Relative(18), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Mul, bit_size: U16, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U16, lhs: Relative(11), rhs: Relative(2) }, Cast { destination: Relative(2), source: Relative(1), bit_size: Integer(U16) }, Const { destination: Relative(5), bit_size: Integer(U16), value: 15 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U16, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(11), location: 454 }, Call { location: 590 }, Const { destination: Relative(7), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U16, lhs: Relative(7), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 458 }, Jump { location: 505 }, Const { destination: Relative(18), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U16, lhs: Relative(1), rhs: Relative(18) }, JumpIf { condition: Relative(11), location: 462 }, Jump { location: 502 }, Const { destination: Relative(19), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(20), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(21), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(22), source: Relative(1), bit_size: Integer(U32) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(23), rhs: Relative(22) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 473 }, BinaryIntOp { destination: Relative(21), op: Mul, bit_size: U16, lhs: Relative(21), rhs: Relative(20) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Jump { location: 467 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(19) }, Const { destination: Relative(28), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U16, lhs: Relative(28), rhs: Relative(2) }, Const { destination: Relative(29), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(30), op: Sub, bit_size: U16, lhs: Relative(29), rhs: Relative(2) }, JumpIf { condition: Relative(23), location: 480 }, Jump { location: 482 }, Mov { destination: Relative(24), source: Relative(30) }, Jump { location: 484 }, Mov { destination: Relative(24), source: Relative(2) }, Jump { location: 484 }, Const { destination: Relative(28), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U16, lhs: Relative(28), rhs: Relative(21) }, Const { destination: Relative(29), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(30), op: Sub, bit_size: U16, lhs: Relative(29), rhs: Relative(21) }, JumpIf { condition: Relative(25), location: 490 }, Jump { location: 492 }, Mov { destination: Relative(26), source: Relative(30) }, Jump { location: 494 }, Mov { destination: Relative(26), source: Relative(21) }, Jump { location: 494 }, BinaryIntOp { destination: Relative(2), op: Div, bit_size: U16, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(27), op: Xor, bit_size: U1, lhs: Relative(23), rhs: Relative(25) }, JumpIf { condition: Relative(27), location: 498 }, Jump { location: 500 }, Const { destination: Relative(28), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(28), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(2), rhs: Relative(19) }, Jump { location: 504 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65535 }, Jump { location: 504 }, Jump { location: 507 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, Jump { location: 507 }, Mov { destination: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U16, lhs: Relative(5), rhs: Relative(4) }, JumpIf { condition: Relative(2), location: 512 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, Const { destination: Relative(2), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(5), source: Relative(4) }, Cast { destination: Relative(4), source: Relative(5), bit_size: Integer(U16) }, Cast { destination: Relative(11), source: Relative(3), bit_size: Integer(U16) }, Const { destination: Relative(3), bit_size: Integer(U16), value: 32768 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U16, lhs: Relative(11), rhs: Relative(3) }, Not { destination: Relative(11), source: Relative(19), bit_size: U1 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U16, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Mul, bit_size: U1, lhs: Relative(19), rhs: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(4), location: 525 }, Call { location: 593 }, Const { destination: Relative(11), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U16, lhs: Relative(11), rhs: Relative(5) }, JumpIf { condition: Relative(4), location: 529 }, Jump { location: 576 }, Const { destination: Relative(20), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U16, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(19), location: 533 }, Jump { location: 573 }, Const { destination: Relative(21), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(22), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(23), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(24), source: Relative(1), bit_size: Integer(U32) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(25), rhs: Relative(24) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 544 }, BinaryIntOp { destination: Relative(23), op: Mul, bit_size: U16, lhs: Relative(23), rhs: Relative(22) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Jump { location: 538 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U16, lhs: Relative(5), rhs: Relative(21) }, Const { destination: Relative(30), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U16, lhs: Relative(30), rhs: Relative(3) }, Const { destination: Relative(31), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U16, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(25), location: 551 }, Jump { location: 553 }, Mov { destination: Relative(26), source: Relative(32) }, Jump { location: 555 }, Mov { destination: Relative(26), source: Relative(3) }, Jump { location: 555 }, Const { destination: Relative(30), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U16, lhs: Relative(30), rhs: Relative(23) }, Const { destination: Relative(31), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U16, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(27), location: 561 }, Jump { location: 563 }, Mov { destination: Relative(28), source: Relative(32) }, Jump { location: 565 }, Mov { destination: Relative(28), source: Relative(23) }, Jump { location: 565 }, BinaryIntOp { destination: Relative(3), op: Div, bit_size: U16, lhs: Relative(26), rhs: Relative(28) }, BinaryIntOp { destination: Relative(29), op: Xor, bit_size: U1, lhs: Relative(25), rhs: Relative(27) }, JumpIf { condition: Relative(29), location: 569 }, Jump { location: 571 }, Const { destination: Relative(30), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U16, lhs: Relative(30), rhs: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U16, lhs: Relative(3), rhs: Relative(21) }, Jump { location: 575 }, Const { destination: Relative(3), bit_size: Integer(U16), value: 65535 }, Jump { location: 575 }, Jump { location: 578 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U16, lhs: Relative(5), rhs: Relative(1) }, Jump { location: 578 }, Mov { destination: Relative(1), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 583 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 589 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pdnBThw5EIDhd5kzhy6Xq1zmVaIoImQSISFAE1hpFfHu62r7J8lhLz2X1E9IfUENbprh1+nb+evbjy8PT9+ff55uP/06fb08PD4+/Pjy+Hx/9/rw/DT+9tdpyz+KnG7l5lTKHDpHncPm8DnaHHG6LWP0feg2h8xR5hiKjjGUOobN4XO0OWKOodjNqW5zyBxlDp1jKD6GzeFztDlijqG0m5MNJcaQOcocOkedYyh9DJ+jzTEU2cbsc/q2pqxZ1tQ165q2pq/Z1lyeL68try2vLa8try2vLa8try2vLa8tL5YXy4vlxfJiebG8WF4sL5YXy+vL68vry+vL68vry+vL68vry+vLk20jhCiEEpUwwolGBIEsyJKyZBRCiUoYkXLJaEQQfUXZCCEKoUQljEAuyAW5ICuyIiuyIiuyIiuyIiuyIlfkilyRK3JFrsgVuSJX5IpsyIZsyIZsyIZsyIZsyIbsyI7syI7syI7syI7syPspG3cb2Y/ZHkIUQomUa0bKlpGyZzQiiJTHfUX2A7eHEIVQIuXIMMKJRgTRV+xHbw8hCqEEckfuyB25I/cll20jhCiEEpUwwolGBIEsyIIsyIIsyIIsyIIsyIJckAtyQS7IBbkgF+SCXJALsiIrsiIrsiIrsiIr8n4Ge0ZfsZ/BPYQoxJDLllEJI5xoRBB9RZ7BGUIUAtmQDdmQDdmQDdmRHdmRHdmRHdmRHdmRHbkhN+SG3JAbckNuyA25ITfkQA7kQA7kQA7kQA7kQA7kjtyRO3JH7sgdOc9gycehPIMzgugzNM/gjJT3p6VCKFEJI5xoRBB9RZ7BGciCnGew5NNXnsEZRqScT115BmcE0VfkGSyWIUQhlKiEESl7RiOC6Cv2R8U9Um4ZKUeGEpUwwomUe0YQfUWewRlCFEKJShjhBHJFrsiGbMiGbMiGbMiGbMiGbMiO7MiO7MiO7MiO7MiO7MgNuSE35IbckBtyQ27IDbkhB3IgB3IgB3IgB3IgB3Igd+Q8g7plFEKJShgxZM3zlWdwRhB9Rs0zOEOIQihRCSOcaEQQyIIsyIIsyIIsyIIsyIIsyAW5IBfkglyQC3JBLsgFuSArsiIrsiIrsiIrsiIrsiJX5IpckStyRa7IFbkiV+SKnGdQS4YQhVAiZc0wwolGBNFX5BmcIUQhlEB2ZEfOM6g1I4i+Is/gDCEKoUQljHACuSE35EAO5EAO5EAO5EAO5EAO5I7ckTtyR+7IHbkjd+SO3Jds20YIUQglKmGEE40IAlmQBVmQBVmQBVmQBVmQBXk/g5YhRCFStvf3mxMvp3x5vZzP+WrKH6+vjFddXu4u56fX0+3T2+Pjzemfu8e3/R/9fLl72ufr3WW8d9zJzk/fxhzg94fHc9b7ze/t7f9Xx4/Ta3n8ZPyxbof225H9PKBzX+O6/VqP7PdY++Nnmev2RQ7sl3z4mft67f6R66/5yLbv66H/XyU+9suV+0c+/+Npin336/bbkY+/KtdvfNs6su+cn3HHP7IfH/vRr9vvR75+TDh/JlfuFz2yr439eu3+ketnzs3X/MjXjzXOr4VcuX/k4/eP+7dvV+6LHdlXrp8fun//uX/o43c+/970yv0j9y/vXL+2bVfuH7n/tcL1a6Vct6965f7f1+/zeOvu/uHy12+c3lO6PNx9fTyvN7+/Pd3/8d7Xf194D7+xerk835+/vV3OKf3+tVU++H2y8e3TdPucr+Pnm+Nubuqf3/O//w8=", + "debug_symbols": "rdnNTlxHEEDhd5k1i9vd9dPNq0SWhfHYQkKAxhApsnj3dN2ug+1FNneySR1C6gtgFzMMP09fz1/evn9+ePr2/ON0+9fP05fLw+Pjw/fPj8/3d68Pz0/z3/48bfGPWk635eZU6xptDVlD17A1/HRb5+hrjH20bY2yxlTaHFOROWQNXcPW8DWmonNMxW5Osq1R1qhrTMXnmEqfQ9ewNXyNqYw5plK2m5NuOUvOmrPllJya03J6zp4zPUvP0rPw5lfCWk7JqTktp+fsOceavuUsOdPz9Dw9T8/T8/Q8PU+vp9fT6+n19Hp6Pb2eXk+vp9fTG+mN9EZ6I72R3khvpDfSG+mN9Mq2EYWoRCOEUMIIJzqBXJALckEuyAW5IBfkglyQC3INuUYUohKNECLkFmGEEyFLxMiIW1kRskZUohEhW4QSRjjRiZDniZS4nxWFqEQjhFDCCCc6gazIiqzIiqzIiqzIiqzIimzIhmzIhmzIhmzIhmzIhuzIjuzIjuzIjuzIjuzIjtyRO3JH7sgduSN35I7ckTvyQB7IA3kg7+fXI5QwwolOhDy/N9b9BvcoRCUaIYQSRjjRCeSCXJALckEuyAW5IBfkglyQK3JFrsgVuSJX5IpckStyRW7IDbkhN+SG3JAbckNuyA1ZkAVZkAVZkAVZkAVZkAVZkRVZkRVZkRVZkRU5brBuESMjbnBFISox5bo/+AuhhBFOdGJkxA2uKEQlkB05brDGc4q4wRVOhNwiRkbc4IpCVCJkiRBCCSOc6MTIiBtcUYiQNaIRQihhRMgW0YmxosUNrihEyB7RCCGUMCLkHtGJkRE3uCLkEVGJRgihxJTbFuFEJ0ZG3OCKQlSiEUIogVyRK3JFbsgNuSE35IbckBtyQ27IDVmQBVmQBVmQBVmQBVmQBVmRFVmRFVmRFVmRFVmRFdmQDdmQDdmQDdmQDdmQDdmR4wZbiahEI4RQIuR4Lh83uKITIyNucEUhKtEIIZRA7sgduSMP5IE8kAfyQB7IA3kgD+SRsmwbUYhKNEIIJYxwohPIBbkgF+SCXJALckEuyAW5IFfkilyRK3JFrsgVuSJX5IrckPcbbBGVaIQQSoQsEU50ImSNH9c2ohCVaITk1n6DeyALsiDvNxg/D+43uEchKtEIIZQwwolOIBuyIRuyIRuyIRuyIRuyITuyIzuyIzuyIzuyIzuyI3fkjtyRO3JH7sgduSN35I48kAfyQB7IA3kgD+SBPJBHyrptRCEq0QghlDDCiZA9YmTsN7hHIULuEY0QQgkjnOjEyNhvcI9CIFfkirzf4IgwwolOjIz9BvcoRCUaIQRyQ27IDbkhC7IgC7IgC7IgC7IgC7IgK7IiK7IiK7IiK7IiK7IiG7IhG7IhG7IhG7IhG7IhO7IjO7IjO7IjO7IjO3LcoOyvF21EIWrE+/vNiZfaPr9ezud4pe23197mK3Ivd5fz0+vp9unt8fHm9Pfd49v+H/14uXva5+vdZb53kuenr3NO8NvD4znq/ebX9vbfq/OFlVyer5F8rOuh/X5kPx5e1n4b1+2LHtkfI/fnT7XX7Zd6YL/G8/y1367dP/L1b/FDyb4/n1Vfue9H9sv42O/X7Ysc2J9P3XJ/Pgs7st/4/OcTmCP7+rFv5cr9I/cznwWw36/cH0fuZz425/58vL1uvx75+unH94/5IHpkX5x9bdft23Zk3z8+/37o83f53/aP3L9tPfft0P3ZVj/25cr9I3//rfHnZ9Ku3D/y/c+M+zPfrty3I/uDj98PPX7+tl+OfPwu/P139ev27cifn/vHx+/juv1u1+2PP+/303zr7v7h8sdvc99DujzcfXk855vf3p7uf3vv6z8vvIffBr9cnu/PX98u55B+/Uo4fpb6S7vcaB+f4ldj8eZoNzr003v87/8F", "file_map": { "50": { - "source": "fn main(x: u64, y: u8, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176, superseded by issue #8791\n assert(u >> (x as u8) == -1);\n assert(z >> (x as u8) == -1);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n\n assert(z >> 16 == -1);\n assert(-z >> x as u8 == 0);\n}\n", + "source": "fn main(x: u64, y: u64, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176, superseded by issue #8791\n assert(u >> (x as i64 - 2) == -1);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> a == 32);\n a = -a;\n assert(a << 6 == -64);\n assert(a << -a == -2);\n\n assert(x >> (x - 1) == 0);\n\n assert_eq(z >> 3, -97);\n\n assert(z >> 14 == -1);\n let rhs = (if x as i16 > 14 { 14 } else { x as i16 });\n assert(z >> rhs == -1);\n assert(-z >> rhs == 0);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_0.snap index 267c78de544..ff0ca849d90 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_0.snap @@ -21,7 +21,7 @@ expression: artifact "type": { "kind": "integer", "sign": "unsigned", - "width": 8 + "width": 64 }, "visibility": "private" }, @@ -68,12 +68,12 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ], EXPR [ (1, _2) 0 ], EXPR [ (1, _3) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32840 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U64) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U8) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U16) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U64) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Mov { destination: Relative(3), source: Direct(32838) }, Mov { destination: Relative(4), source: Direct(32839) }, Call { location: 19 }, Call { location: 20 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 525 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 64 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(8), location: 28 }, Call { location: 531 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 128 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 33 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, BinaryIntOp { destination: Relative(6), op: Shr, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(8), location: 39 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 64 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 44 }, Call { location: 531 }, Const { destination: Relative(6), bit_size: Integer(U64), value: 128 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 49 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(5), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U64), value: 32 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 55 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Cast { destination: Relative(6), source: Relative(1), bit_size: Integer(U8) }, Cast { destination: Relative(5), source: Relative(6), bit_size: Integer(U64) }, Cast { destination: Relative(6), source: Relative(5), bit_size: Integer(U8) }, Const { destination: Relative(10), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U64, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 62 }, Jump { location: 109 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 64 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(12) }, JumpIf { condition: Relative(11), location: 66 }, Jump { location: 106 }, Const { destination: Relative(13), bit_size: Integer(U64), value: 1 }, Const { destination: Relative(14), bit_size: Integer(U64), value: 2 }, Const { destination: Relative(15), bit_size: Integer(U64), value: 1 }, Cast { destination: Relative(16), source: Relative(6), bit_size: Integer(U32) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Relative(16) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 77 }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Jump { location: 71 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(13) }, Const { destination: Relative(22), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U64, lhs: Relative(22), rhs: Relative(8) }, Const { destination: Relative(23), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(24), op: Sub, bit_size: U64, lhs: Relative(23), rhs: Relative(8) }, JumpIf { condition: Relative(17), location: 84 }, Jump { location: 86 }, Mov { destination: Relative(18), source: Relative(24) }, Jump { location: 88 }, Mov { destination: Relative(18), source: Relative(8) }, Jump { location: 88 }, Const { destination: Relative(22), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U64, lhs: Relative(22), rhs: Relative(15) }, Const { destination: Relative(23), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(24), op: Sub, bit_size: U64, lhs: Relative(23), rhs: Relative(15) }, JumpIf { condition: Relative(19), location: 94 }, Jump { location: 96 }, Mov { destination: Relative(20), source: Relative(24) }, Jump { location: 98 }, Mov { destination: Relative(20), source: Relative(15) }, Jump { location: 98 }, BinaryIntOp { destination: Relative(8), op: Div, bit_size: U64, lhs: Relative(18), rhs: Relative(20) }, BinaryIntOp { destination: Relative(21), op: Xor, bit_size: U1, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(21), location: 102 }, Jump { location: 104 }, Const { destination: Relative(22), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U64, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U64, lhs: Relative(8), rhs: Relative(13) }, Jump { location: 108 }, Const { destination: Relative(8), bit_size: Integer(U64), value: 18446744073709551615 }, Jump { location: 108 }, Jump { location: 111 }, BinaryIntOp { destination: Relative(8), op: Shr, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, Jump { location: 111 }, Const { destination: Relative(4), bit_size: Integer(U64), value: 18446744073709551615 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U64, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 116 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, Const { destination: Relative(9), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U16, lhs: Relative(9), rhs: Relative(3) }, JumpIf { condition: Relative(8), location: 120 }, Jump { location: 167 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(13) }, JumpIf { condition: Relative(11), location: 124 }, Jump { location: 164 }, Const { destination: Relative(14), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(15), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(16), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(17), source: Relative(6), bit_size: Integer(U32) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(17) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 135 }, BinaryIntOp { destination: Relative(16), op: Mul, bit_size: U16, lhs: Relative(16), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Jump { location: 129 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(14) }, Const { destination: Relative(23), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U16, lhs: Relative(23), rhs: Relative(4) }, Const { destination: Relative(24), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(25), op: Sub, bit_size: U16, lhs: Relative(24), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 142 }, Jump { location: 144 }, Mov { destination: Relative(19), source: Relative(25) }, Jump { location: 146 }, Mov { destination: Relative(19), source: Relative(4) }, Jump { location: 146 }, Const { destination: Relative(23), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U16, lhs: Relative(23), rhs: Relative(16) }, Const { destination: Relative(24), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(25), op: Sub, bit_size: U16, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(20), location: 152 }, Jump { location: 154 }, Mov { destination: Relative(21), source: Relative(25) }, Jump { location: 156 }, Mov { destination: Relative(21), source: Relative(16) }, Jump { location: 156 }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U16, lhs: Relative(19), rhs: Relative(21) }, BinaryIntOp { destination: Relative(22), op: Xor, bit_size: U1, lhs: Relative(18), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 160 }, Jump { location: 162 }, Const { destination: Relative(23), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(23), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(4), rhs: Relative(14) }, Jump { location: 166 }, Const { destination: Relative(4), bit_size: Integer(U16), value: 65535 }, Jump { location: 166 }, Jump { location: 169 }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(6) }, Jump { location: 169 }, Const { destination: Relative(8), bit_size: Integer(U16), value: 65535 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U16, lhs: Relative(4), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Cast { destination: Relative(4), source: Relative(2), bit_size: Integer(U8) }, Cast { destination: Relative(11), source: Relative(5), bit_size: Integer(U8) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(14), op: Shl, bit_size: U8, lhs: Relative(11), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(14) }, Const { destination: Relative(14), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(14) }, JumpIf { condition: Relative(15), location: 184 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Const { destination: Relative(5), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U8, lhs: Relative(17), rhs: Relative(11) }, JumpIf { condition: Relative(16), location: 189 }, Jump { location: 236 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U8, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(18), location: 193 }, Jump { location: 233 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 1 }, Cast { destination: Relative(23), source: Relative(5), bit_size: Integer(U32) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U32, lhs: Relative(24), rhs: Relative(23) }, Not { destination: Relative(25), source: Relative(25), bit_size: U1 }, JumpIf { condition: Relative(25), location: 204 }, BinaryIntOp { destination: Relative(22), op: Mul, bit_size: U8, lhs: Relative(22), rhs: Relative(21) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Jump { location: 198 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U8, lhs: Relative(11), rhs: Relative(20) }, Const { destination: Relative(29), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U8, lhs: Relative(29), rhs: Relative(15) }, Const { destination: Relative(30), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(31), op: Sub, bit_size: U8, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(24), location: 211 }, Jump { location: 213 }, Mov { destination: Relative(25), source: Relative(31) }, Jump { location: 215 }, Mov { destination: Relative(25), source: Relative(15) }, Jump { location: 215 }, Const { destination: Relative(29), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U8, lhs: Relative(29), rhs: Relative(22) }, Const { destination: Relative(30), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(31), op: Sub, bit_size: U8, lhs: Relative(30), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 221 }, Jump { location: 223 }, Mov { destination: Relative(27), source: Relative(31) }, Jump { location: 225 }, Mov { destination: Relative(27), source: Relative(22) }, Jump { location: 225 }, BinaryIntOp { destination: Relative(15), op: Div, bit_size: U8, lhs: Relative(25), rhs: Relative(27) }, BinaryIntOp { destination: Relative(28), op: Xor, bit_size: U1, lhs: Relative(24), rhs: Relative(26) }, JumpIf { condition: Relative(28), location: 229 }, Jump { location: 231 }, Const { destination: Relative(29), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U8, lhs: Relative(29), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U8, lhs: Relative(15), rhs: Relative(20) }, Jump { location: 235 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 255 }, Jump { location: 235 }, Jump { location: 238 }, BinaryIntOp { destination: Relative(15), op: Shr, bit_size: U8, lhs: Relative(11), rhs: Relative(5) }, Jump { location: 238 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U8, lhs: Relative(15), rhs: Relative(5) }, JumpIf { condition: Relative(16), location: 243 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(16), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U8, lhs: Relative(16), rhs: Relative(11) }, JumpIf { condition: Relative(15), location: 247 }, Jump { location: 294 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 251 }, Jump { location: 291 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 1 }, Cast { destination: Relative(24), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(25), rhs: Relative(24) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 262 }, BinaryIntOp { destination: Relative(23), op: Mul, bit_size: U8, lhs: Relative(23), rhs: Relative(22) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Jump { location: 256 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U8, lhs: Relative(11), rhs: Relative(21) }, Const { destination: Relative(30), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U8, lhs: Relative(30), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U8, lhs: Relative(31), rhs: Relative(5) }, JumpIf { condition: Relative(25), location: 269 }, Jump { location: 271 }, Mov { destination: Relative(26), source: Relative(32) }, Jump { location: 273 }, Mov { destination: Relative(26), source: Relative(5) }, Jump { location: 273 }, Const { destination: Relative(30), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U8, lhs: Relative(30), rhs: Relative(23) }, Const { destination: Relative(31), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U8, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(27), location: 279 }, Jump { location: 281 }, Mov { destination: Relative(28), source: Relative(32) }, Jump { location: 283 }, Mov { destination: Relative(28), source: Relative(23) }, Jump { location: 283 }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U8, lhs: Relative(26), rhs: Relative(28) }, BinaryIntOp { destination: Relative(29), op: Xor, bit_size: U1, lhs: Relative(25), rhs: Relative(27) }, JumpIf { condition: Relative(29), location: 287 }, Jump { location: 289 }, Const { destination: Relative(30), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U8, lhs: Relative(30), rhs: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U8, lhs: Relative(5), rhs: Relative(21) }, Jump { location: 293 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 255 }, Jump { location: 293 }, Jump { location: 296 }, BinaryIntOp { destination: Relative(5), op: Shr, bit_size: U8, lhs: Relative(11), rhs: Relative(2) }, Jump { location: 296 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(15), location: 301 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(5), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U8, lhs: Relative(5), rhs: Relative(4) }, Mov { destination: Relative(4), source: Relative(11) }, Cast { destination: Relative(5), source: Relative(4), bit_size: Integer(U8) }, Const { destination: Relative(11), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(11) }, Not { destination: Relative(18), source: Relative(15), bit_size: U1 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U8, lhs: Relative(5), rhs: Relative(11) }, BinaryIntOp { destination: Relative(5), op: Mul, bit_size: U1, lhs: Relative(15), rhs: Relative(18) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U1, lhs: Relative(5), rhs: Relative(18) }, JumpIf { condition: Relative(11), location: 313 }, Call { location: 534 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 7 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U8, lhs: Relative(4), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(14) }, JumpIf { condition: Relative(11), location: 320 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U8, lhs: Relative(4), rhs: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(11), location: 325 }, Call { location: 531 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 254 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U8, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 331 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 337 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U16, lhs: Relative(5), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 342 }, Jump { location: 389 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U8, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(7), location: 346 }, Jump { location: 386 }, Const { destination: Relative(14), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(15), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(18), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(21), source: Relative(1), bit_size: Integer(U32) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 357 }, BinaryIntOp { destination: Relative(18), op: Mul, bit_size: U16, lhs: Relative(18), rhs: Relative(15) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Jump { location: 351 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(14) }, Const { destination: Relative(27), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U16, lhs: Relative(27), rhs: Relative(2) }, Const { destination: Relative(28), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U16, lhs: Relative(28), rhs: Relative(2) }, JumpIf { condition: Relative(22), location: 364 }, Jump { location: 366 }, Mov { destination: Relative(23), source: Relative(29) }, Jump { location: 368 }, Mov { destination: Relative(23), source: Relative(2) }, Jump { location: 368 }, Const { destination: Relative(27), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U16, lhs: Relative(27), rhs: Relative(18) }, Const { destination: Relative(28), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U16, lhs: Relative(28), rhs: Relative(18) }, JumpIf { condition: Relative(24), location: 374 }, Jump { location: 376 }, Mov { destination: Relative(25), source: Relative(29) }, Jump { location: 378 }, Mov { destination: Relative(25), source: Relative(18) }, Jump { location: 378 }, BinaryIntOp { destination: Relative(2), op: Div, bit_size: U16, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(26), op: Xor, bit_size: U1, lhs: Relative(22), rhs: Relative(24) }, JumpIf { condition: Relative(26), location: 382 }, Jump { location: 384 }, Const { destination: Relative(27), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(27), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(2), rhs: Relative(14) }, Jump { location: 388 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65535 }, Jump { location: 388 }, Jump { location: 391 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, Jump { location: 391 }, Const { destination: Relative(1), bit_size: Integer(U16), value: 65439 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 396 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 16 }, Const { destination: Relative(7), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U16, lhs: Relative(7), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 401 }, Jump { location: 448 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U8, lhs: Relative(1), rhs: Relative(15) }, JumpIf { condition: Relative(14), location: 405 }, Jump { location: 445 }, Const { destination: Relative(18), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(21), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(22), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(23), source: Relative(1), bit_size: Integer(U32) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U32, lhs: Relative(24), rhs: Relative(23) }, Not { destination: Relative(25), source: Relative(25), bit_size: U1 }, JumpIf { condition: Relative(25), location: 416 }, BinaryIntOp { destination: Relative(22), op: Mul, bit_size: U16, lhs: Relative(22), rhs: Relative(21) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Jump { location: 410 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(18) }, Const { destination: Relative(29), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U16, lhs: Relative(29), rhs: Relative(2) }, Const { destination: Relative(30), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(31), op: Sub, bit_size: U16, lhs: Relative(30), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 423 }, Jump { location: 425 }, Mov { destination: Relative(25), source: Relative(31) }, Jump { location: 427 }, Mov { destination: Relative(25), source: Relative(2) }, Jump { location: 427 }, Const { destination: Relative(29), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U16, lhs: Relative(29), rhs: Relative(22) }, Const { destination: Relative(30), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(31), op: Sub, bit_size: U16, lhs: Relative(30), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 433 }, Jump { location: 435 }, Mov { destination: Relative(27), source: Relative(31) }, Jump { location: 437 }, Mov { destination: Relative(27), source: Relative(22) }, Jump { location: 437 }, BinaryIntOp { destination: Relative(2), op: Div, bit_size: U16, lhs: Relative(25), rhs: Relative(27) }, BinaryIntOp { destination: Relative(28), op: Xor, bit_size: U1, lhs: Relative(24), rhs: Relative(26) }, JumpIf { condition: Relative(28), location: 441 }, Jump { location: 443 }, Const { destination: Relative(29), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(29), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(2), rhs: Relative(18) }, Jump { location: 447 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65535 }, Jump { location: 447 }, Jump { location: 450 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, Jump { location: 450 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(1), location: 454 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(1), rhs: Relative(3) }, Mov { destination: Relative(4), source: Relative(2) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Integer(U16) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Integer(U16) }, Const { destination: Relative(3), bit_size: Integer(U16), value: 32768 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U16, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(14), bit_size: U1 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U16, lhs: Relative(2), rhs: Relative(3) }, BinaryIntOp { destination: Relative(2), op: Mul, bit_size: U1, lhs: Relative(14), rhs: Relative(8) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(3), location: 467 }, Call { location: 534 }, Const { destination: Relative(8), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U16, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(3), location: 471 }, Jump { location: 518 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(18) }, JumpIf { condition: Relative(14), location: 475 }, Jump { location: 515 }, Const { destination: Relative(21), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(22), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(23), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(24), source: Relative(6), bit_size: Integer(U32) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(25), rhs: Relative(24) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 486 }, BinaryIntOp { destination: Relative(23), op: Mul, bit_size: U16, lhs: Relative(23), rhs: Relative(22) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Jump { location: 480 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U16, lhs: Relative(4), rhs: Relative(21) }, Const { destination: Relative(30), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U16, lhs: Relative(30), rhs: Relative(2) }, Const { destination: Relative(31), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U16, lhs: Relative(31), rhs: Relative(2) }, JumpIf { condition: Relative(25), location: 493 }, Jump { location: 495 }, Mov { destination: Relative(26), source: Relative(32) }, Jump { location: 497 }, Mov { destination: Relative(26), source: Relative(2) }, Jump { location: 497 }, Const { destination: Relative(30), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U16, lhs: Relative(30), rhs: Relative(23) }, Const { destination: Relative(31), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U16, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(27), location: 503 }, Jump { location: 505 }, Mov { destination: Relative(28), source: Relative(32) }, Jump { location: 507 }, Mov { destination: Relative(28), source: Relative(23) }, Jump { location: 507 }, BinaryIntOp { destination: Relative(2), op: Div, bit_size: U16, lhs: Relative(26), rhs: Relative(28) }, BinaryIntOp { destination: Relative(29), op: Xor, bit_size: U1, lhs: Relative(25), rhs: Relative(27) }, JumpIf { condition: Relative(29), location: 511 }, Jump { location: 513 }, Const { destination: Relative(30), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(30), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(2), rhs: Relative(21) }, Jump { location: 517 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65535 }, Jump { location: 517 }, Jump { location: 520 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(4), rhs: Relative(6) }, Jump { location: 520 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 524 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 530 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32840 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U64) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U64) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U16) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U64) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Mov { destination: Relative(3), source: Direct(32838) }, Mov { destination: Relative(4), source: Direct(32839) }, Call { location: 19 }, Call { location: 20 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 584 }, Const { destination: Relative(5), bit_size: Integer(U64), value: 64 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U64, lhs: Relative(2), rhs: Relative(5) }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 26 }, Call { location: 590 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U64), value: 128 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U64, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 32 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, BinaryIntOp { destination: Relative(6), op: Shr, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(9), bit_size: Integer(U64), value: 32 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U64, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(10), location: 38 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U64, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(10), location: 43 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, BinaryIntOp { destination: Relative(6), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U64, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(8), location: 48 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Cast { destination: Relative(6), source: Relative(1), bit_size: Integer(U64) }, Const { destination: Relative(8), bit_size: Integer(U64), value: 2 }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U64, lhs: Relative(6), rhs: Relative(8) }, Mov { destination: Relative(6), source: Relative(9) }, Cast { destination: Relative(8), source: Relative(6), bit_size: Integer(U64) }, Const { destination: Relative(9), bit_size: Integer(U64), value: 9223372036854775808 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U64, lhs: Relative(1), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(10), bit_size: U1 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U64, lhs: Relative(8), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(12), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U1, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(9), location: 62 }, Call { location: 593 }, Const { destination: Relative(9), bit_size: Integer(U64), value: 63 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U64, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(10), location: 66 }, Call { location: 590 }, Const { destination: Relative(10), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U64, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 70 }, Jump { location: 117 }, Const { destination: Relative(12), bit_size: Integer(U64), value: 64 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U64, lhs: Relative(6), rhs: Relative(12) }, JumpIf { condition: Relative(11), location: 74 }, Jump { location: 114 }, Const { destination: Relative(13), bit_size: Integer(U64), value: 1 }, Const { destination: Relative(14), bit_size: Integer(U64), value: 2 }, Const { destination: Relative(15), bit_size: Integer(U64), value: 1 }, Cast { destination: Relative(16), source: Relative(6), bit_size: Integer(U32) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Relative(16) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 85 }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Jump { location: 79 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(13) }, Const { destination: Relative(22), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U64, lhs: Relative(22), rhs: Relative(8) }, Const { destination: Relative(23), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(24), op: Sub, bit_size: U64, lhs: Relative(23), rhs: Relative(8) }, JumpIf { condition: Relative(17), location: 92 }, Jump { location: 94 }, Mov { destination: Relative(18), source: Relative(24) }, Jump { location: 96 }, Mov { destination: Relative(18), source: Relative(8) }, Jump { location: 96 }, Const { destination: Relative(22), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U64, lhs: Relative(22), rhs: Relative(15) }, Const { destination: Relative(23), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(24), op: Sub, bit_size: U64, lhs: Relative(23), rhs: Relative(15) }, JumpIf { condition: Relative(19), location: 102 }, Jump { location: 104 }, Mov { destination: Relative(20), source: Relative(24) }, Jump { location: 106 }, Mov { destination: Relative(20), source: Relative(15) }, Jump { location: 106 }, BinaryIntOp { destination: Relative(8), op: Div, bit_size: U64, lhs: Relative(18), rhs: Relative(20) }, BinaryIntOp { destination: Relative(21), op: Xor, bit_size: U1, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(21), location: 110 }, Jump { location: 112 }, Const { destination: Relative(22), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U64, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U64, lhs: Relative(8), rhs: Relative(13) }, Jump { location: 116 }, Const { destination: Relative(8), bit_size: Integer(U64), value: 18446744073709551615 }, Jump { location: 116 }, Jump { location: 119 }, BinaryIntOp { destination: Relative(8), op: Shr, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, Jump { location: 119 }, Mov { destination: Relative(4), source: Relative(8) }, Const { destination: Relative(6), bit_size: Integer(U64), value: 18446744073709551615 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 125 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Cast { destination: Relative(6), source: Relative(2), bit_size: Integer(U8) }, Cast { destination: Relative(4), source: Relative(6), bit_size: Integer(U64) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Integer(U8) }, Cast { destination: Relative(8), source: Relative(1), bit_size: Integer(U8) }, Cast { destination: Relative(6), source: Relative(8), bit_size: Integer(U64) }, Cast { destination: Relative(8), source: Relative(6), bit_size: Integer(U8) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(9), op: Shl, bit_size: U8, lhs: Relative(8), rhs: Relative(6) }, Mov { destination: Relative(6), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 139 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(6), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U8, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 144 }, Jump { location: 191 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(15) }, JumpIf { condition: Relative(14), location: 148 }, Jump { location: 188 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 1 }, Cast { destination: Relative(19), source: Relative(6), bit_size: Integer(U32) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(19) }, Not { destination: Relative(21), source: Relative(21), bit_size: U1 }, JumpIf { condition: Relative(21), location: 159 }, BinaryIntOp { destination: Relative(18), op: Mul, bit_size: U8, lhs: Relative(18), rhs: Relative(17) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Jump { location: 153 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U8, lhs: Relative(8), rhs: Relative(16) }, Const { destination: Relative(25), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U8, lhs: Relative(25), rhs: Relative(9) }, Const { destination: Relative(26), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(27), op: Sub, bit_size: U8, lhs: Relative(26), rhs: Relative(9) }, JumpIf { condition: Relative(20), location: 166 }, Jump { location: 168 }, Mov { destination: Relative(21), source: Relative(27) }, Jump { location: 170 }, Mov { destination: Relative(21), source: Relative(9) }, Jump { location: 170 }, Const { destination: Relative(25), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U8, lhs: Relative(25), rhs: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(27), op: Sub, bit_size: U8, lhs: Relative(26), rhs: Relative(18) }, JumpIf { condition: Relative(22), location: 176 }, Jump { location: 178 }, Mov { destination: Relative(23), source: Relative(27) }, Jump { location: 180 }, Mov { destination: Relative(23), source: Relative(18) }, Jump { location: 180 }, BinaryIntOp { destination: Relative(9), op: Div, bit_size: U8, lhs: Relative(21), rhs: Relative(23) }, BinaryIntOp { destination: Relative(24), op: Xor, bit_size: U1, lhs: Relative(20), rhs: Relative(22) }, JumpIf { condition: Relative(24), location: 184 }, Jump { location: 186 }, Const { destination: Relative(25), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U8, lhs: Relative(25), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U8, lhs: Relative(9), rhs: Relative(16) }, Jump { location: 190 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 255 }, Jump { location: 190 }, Jump { location: 193 }, BinaryIntOp { destination: Relative(9), op: Shr, bit_size: U8, lhs: Relative(8), rhs: Relative(6) }, Jump { location: 193 }, Mov { destination: Relative(6), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 199 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Cast { destination: Relative(6), source: Relative(4), bit_size: Integer(U8) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 7 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 204 }, Call { location: 590 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U8, lhs: Relative(14), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 208 }, Jump { location: 255 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(17) }, JumpIf { condition: Relative(16), location: 212 }, Jump { location: 252 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 1 }, Cast { destination: Relative(21), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 223 }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U8, lhs: Relative(20), rhs: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Jump { location: 217 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U8, lhs: Relative(8), rhs: Relative(18) }, Const { destination: Relative(27), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U8, lhs: Relative(27), rhs: Relative(9) }, Const { destination: Relative(28), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U8, lhs: Relative(28), rhs: Relative(9) }, JumpIf { condition: Relative(22), location: 230 }, Jump { location: 232 }, Mov { destination: Relative(23), source: Relative(29) }, Jump { location: 234 }, Mov { destination: Relative(23), source: Relative(9) }, Jump { location: 234 }, Const { destination: Relative(27), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U8, lhs: Relative(27), rhs: Relative(20) }, Const { destination: Relative(28), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U8, lhs: Relative(28), rhs: Relative(20) }, JumpIf { condition: Relative(24), location: 240 }, Jump { location: 242 }, Mov { destination: Relative(25), source: Relative(29) }, Jump { location: 244 }, Mov { destination: Relative(25), source: Relative(20) }, Jump { location: 244 }, BinaryIntOp { destination: Relative(9), op: Div, bit_size: U8, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(26), op: Xor, bit_size: U1, lhs: Relative(22), rhs: Relative(24) }, JumpIf { condition: Relative(26), location: 248 }, Jump { location: 250 }, Const { destination: Relative(27), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U8, lhs: Relative(27), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U8, lhs: Relative(9), rhs: Relative(18) }, Jump { location: 254 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 255 }, Jump { location: 254 }, Jump { location: 257 }, BinaryIntOp { destination: Relative(9), op: Shr, bit_size: U8, lhs: Relative(8), rhs: Relative(2) }, Jump { location: 257 }, Mov { destination: Relative(8), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 263 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Const { destination: Relative(8), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U8, lhs: Relative(8), rhs: Relative(2) }, Mov { destination: Relative(2), source: Relative(9) }, Cast { destination: Relative(9), source: Relative(2), bit_size: Integer(U8) }, Const { destination: Relative(11), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(11) }, Not { destination: Relative(6), source: Relative(16), bit_size: U1 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U8, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(9), op: Mul, bit_size: U1, lhs: Relative(16), rhs: Relative(6) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(6) }, JumpIf { condition: Relative(18), location: 275 }, Call { location: 593 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 6 }, BinaryIntOp { destination: Relative(9), op: Shl, bit_size: U8, lhs: Relative(2), rhs: Relative(6) }, Mov { destination: Relative(6), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U8), value: 192 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(18), location: 283 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U8, lhs: Relative(8), rhs: Relative(2) }, Mov { destination: Relative(8), source: Relative(6) }, Cast { destination: Relative(6), source: Relative(8), bit_size: Integer(U8) }, Not { destination: Relative(9), source: Relative(16), bit_size: U1 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Mul, bit_size: U1, lhs: Relative(16), rhs: Relative(9) }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U1, lhs: Relative(11), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 292 }, Call { location: 593 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 295 }, Call { location: 590 }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U8, lhs: Relative(2), rhs: Relative(8) }, Mov { destination: Relative(2), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 254 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U8, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 302 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(2), bit_size: Integer(U64), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 307 }, Call { location: 593 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(2), location: 310 }, Call { location: 590 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 316 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Const { destination: Relative(2), bit_size: Integer(U16), value: 3 }, Const { destination: Relative(6), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U16, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 321 }, Jump { location: 368 }, Const { destination: Relative(9), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U16, lhs: Relative(2), rhs: Relative(9) }, JumpIf { condition: Relative(8), location: 325 }, Jump { location: 365 }, Const { destination: Relative(11), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(16), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(18), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(19), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(19) }, Not { destination: Relative(21), source: Relative(21), bit_size: U1 }, JumpIf { condition: Relative(21), location: 336 }, BinaryIntOp { destination: Relative(18), op: Mul, bit_size: U16, lhs: Relative(18), rhs: Relative(16) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Jump { location: 330 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(11) }, Const { destination: Relative(25), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U16, lhs: Relative(25), rhs: Relative(4) }, Const { destination: Relative(26), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(27), op: Sub, bit_size: U16, lhs: Relative(26), rhs: Relative(4) }, JumpIf { condition: Relative(20), location: 343 }, Jump { location: 345 }, Mov { destination: Relative(21), source: Relative(27) }, Jump { location: 347 }, Mov { destination: Relative(21), source: Relative(4) }, Jump { location: 347 }, Const { destination: Relative(25), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U16, lhs: Relative(25), rhs: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(27), op: Sub, bit_size: U16, lhs: Relative(26), rhs: Relative(18) }, JumpIf { condition: Relative(22), location: 353 }, Jump { location: 355 }, Mov { destination: Relative(23), source: Relative(27) }, Jump { location: 357 }, Mov { destination: Relative(23), source: Relative(18) }, Jump { location: 357 }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U16, lhs: Relative(21), rhs: Relative(23) }, BinaryIntOp { destination: Relative(24), op: Xor, bit_size: U1, lhs: Relative(20), rhs: Relative(22) }, JumpIf { condition: Relative(24), location: 361 }, Jump { location: 363 }, Const { destination: Relative(25), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(25), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(4), rhs: Relative(11) }, Jump { location: 367 }, Const { destination: Relative(4), bit_size: Integer(U16), value: 65535 }, Jump { location: 367 }, Jump { location: 370 }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(2) }, Jump { location: 370 }, Mov { destination: Relative(2), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U16), value: 65439 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 376 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(2), bit_size: Integer(U16), value: 14 }, Const { destination: Relative(8), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U16, lhs: Relative(8), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 381 }, Jump { location: 428 }, Const { destination: Relative(16), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U16, lhs: Relative(2), rhs: Relative(16) }, JumpIf { condition: Relative(11), location: 385 }, Jump { location: 425 }, Const { destination: Relative(18), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(19), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(20), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(21), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 396 }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U16, lhs: Relative(20), rhs: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Jump { location: 390 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(18) }, Const { destination: Relative(27), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U16, lhs: Relative(27), rhs: Relative(4) }, Const { destination: Relative(28), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U16, lhs: Relative(28), rhs: Relative(4) }, JumpIf { condition: Relative(22), location: 403 }, Jump { location: 405 }, Mov { destination: Relative(23), source: Relative(29) }, Jump { location: 407 }, Mov { destination: Relative(23), source: Relative(4) }, Jump { location: 407 }, Const { destination: Relative(27), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U16, lhs: Relative(27), rhs: Relative(20) }, Const { destination: Relative(28), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U16, lhs: Relative(28), rhs: Relative(20) }, JumpIf { condition: Relative(24), location: 413 }, Jump { location: 415 }, Mov { destination: Relative(25), source: Relative(29) }, Jump { location: 417 }, Mov { destination: Relative(25), source: Relative(20) }, Jump { location: 417 }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U16, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(26), op: Xor, bit_size: U1, lhs: Relative(22), rhs: Relative(24) }, JumpIf { condition: Relative(26), location: 421 }, Jump { location: 423 }, Const { destination: Relative(27), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(27), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(4), rhs: Relative(18) }, Jump { location: 427 }, Const { destination: Relative(4), bit_size: Integer(U16), value: 65535 }, Jump { location: 427 }, Jump { location: 430 }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(2) }, Jump { location: 430 }, Mov { destination: Relative(5), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U16), value: 65535 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U16, lhs: Relative(5), rhs: Relative(4) }, JumpIf { condition: Relative(11), location: 436 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Cast { destination: Relative(11), source: Relative(1), bit_size: Integer(U16) }, Cast { destination: Relative(5), source: Relative(11), bit_size: Integer(U64) }, Cast { destination: Relative(1), source: Relative(5), bit_size: Integer(U16) }, Const { destination: Relative(19), bit_size: Integer(U16), value: 32768 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U16, lhs: Relative(2), rhs: Relative(19) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U16, lhs: Relative(1), rhs: Relative(19) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U16, lhs: Relative(11), rhs: Relative(18) }, Not { destination: Relative(11), source: Relative(5), bit_size: U1 }, Cast { destination: Relative(18), source: Relative(5), bit_size: Integer(U16) }, Cast { destination: Relative(5), source: Relative(11), bit_size: Integer(U16) }, BinaryIntOp { destination: Relative(11), op: Mul, bit_size: U16, lhs: Relative(18), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Mul, bit_size: U16, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U16, lhs: Relative(11), rhs: Relative(2) }, Cast { destination: Relative(2), source: Relative(1), bit_size: Integer(U16) }, Const { destination: Relative(5), bit_size: Integer(U16), value: 15 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U16, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(11), location: 454 }, Call { location: 590 }, Const { destination: Relative(7), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U16, lhs: Relative(7), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 458 }, Jump { location: 505 }, Const { destination: Relative(18), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U16, lhs: Relative(1), rhs: Relative(18) }, JumpIf { condition: Relative(11), location: 462 }, Jump { location: 502 }, Const { destination: Relative(19), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(20), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(21), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(22), source: Relative(1), bit_size: Integer(U32) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(23), rhs: Relative(22) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 473 }, BinaryIntOp { destination: Relative(21), op: Mul, bit_size: U16, lhs: Relative(21), rhs: Relative(20) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Jump { location: 467 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(19) }, Const { destination: Relative(28), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U16, lhs: Relative(28), rhs: Relative(2) }, Const { destination: Relative(29), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(30), op: Sub, bit_size: U16, lhs: Relative(29), rhs: Relative(2) }, JumpIf { condition: Relative(23), location: 480 }, Jump { location: 482 }, Mov { destination: Relative(24), source: Relative(30) }, Jump { location: 484 }, Mov { destination: Relative(24), source: Relative(2) }, Jump { location: 484 }, Const { destination: Relative(28), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U16, lhs: Relative(28), rhs: Relative(21) }, Const { destination: Relative(29), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(30), op: Sub, bit_size: U16, lhs: Relative(29), rhs: Relative(21) }, JumpIf { condition: Relative(25), location: 490 }, Jump { location: 492 }, Mov { destination: Relative(26), source: Relative(30) }, Jump { location: 494 }, Mov { destination: Relative(26), source: Relative(21) }, Jump { location: 494 }, BinaryIntOp { destination: Relative(2), op: Div, bit_size: U16, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(27), op: Xor, bit_size: U1, lhs: Relative(23), rhs: Relative(25) }, JumpIf { condition: Relative(27), location: 498 }, Jump { location: 500 }, Const { destination: Relative(28), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(28), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(2), rhs: Relative(19) }, Jump { location: 504 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65535 }, Jump { location: 504 }, Jump { location: 507 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, Jump { location: 507 }, Mov { destination: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U16, lhs: Relative(5), rhs: Relative(4) }, JumpIf { condition: Relative(2), location: 512 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, Const { destination: Relative(2), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(5), source: Relative(4) }, Cast { destination: Relative(4), source: Relative(5), bit_size: Integer(U16) }, Cast { destination: Relative(11), source: Relative(3), bit_size: Integer(U16) }, Const { destination: Relative(3), bit_size: Integer(U16), value: 32768 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U16, lhs: Relative(11), rhs: Relative(3) }, Not { destination: Relative(11), source: Relative(19), bit_size: U1 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U16, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Mul, bit_size: U1, lhs: Relative(19), rhs: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(4), location: 525 }, Call { location: 593 }, Const { destination: Relative(11), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U16, lhs: Relative(11), rhs: Relative(5) }, JumpIf { condition: Relative(4), location: 529 }, Jump { location: 576 }, Const { destination: Relative(20), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U16, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(19), location: 533 }, Jump { location: 573 }, Const { destination: Relative(21), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(22), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(23), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(24), source: Relative(1), bit_size: Integer(U32) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(25), rhs: Relative(24) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 544 }, BinaryIntOp { destination: Relative(23), op: Mul, bit_size: U16, lhs: Relative(23), rhs: Relative(22) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Jump { location: 538 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U16, lhs: Relative(5), rhs: Relative(21) }, Const { destination: Relative(30), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U16, lhs: Relative(30), rhs: Relative(3) }, Const { destination: Relative(31), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U16, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(25), location: 551 }, Jump { location: 553 }, Mov { destination: Relative(26), source: Relative(32) }, Jump { location: 555 }, Mov { destination: Relative(26), source: Relative(3) }, Jump { location: 555 }, Const { destination: Relative(30), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U16, lhs: Relative(30), rhs: Relative(23) }, Const { destination: Relative(31), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U16, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(27), location: 561 }, Jump { location: 563 }, Mov { destination: Relative(28), source: Relative(32) }, Jump { location: 565 }, Mov { destination: Relative(28), source: Relative(23) }, Jump { location: 565 }, BinaryIntOp { destination: Relative(3), op: Div, bit_size: U16, lhs: Relative(26), rhs: Relative(28) }, BinaryIntOp { destination: Relative(29), op: Xor, bit_size: U1, lhs: Relative(25), rhs: Relative(27) }, JumpIf { condition: Relative(29), location: 569 }, Jump { location: 571 }, Const { destination: Relative(30), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U16, lhs: Relative(30), rhs: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U16, lhs: Relative(3), rhs: Relative(21) }, Jump { location: 575 }, Const { destination: Relative(3), bit_size: Integer(U16), value: 65535 }, Jump { location: 575 }, Jump { location: 578 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U16, lhs: Relative(5), rhs: Relative(1) }, Jump { location: 578 }, Mov { destination: Relative(1), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 583 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 589 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pdnBThw5EIDhd5kzhy6Xq1zmVaIoImQSISFAE1hpFfHu62r7J8lhLz2X1E9IfUENbprh1+nb+evbjy8PT9+ff55uP/06fb08PD4+/Pjy+Hx/9/rw/DT+9tdpyz+KnG7l5lTKHDpHncPm8DnaHHG6LWP0feg2h8xR5hiKjjGUOobN4XO0OWKOodjNqW5zyBxlDp1jKD6GzeFztDlijqG0m5MNJcaQOcocOkedYyh9DJ+jzTEU2cbsc/q2pqxZ1tQ165q2pq/Z1lyeL68try2vLa8try2vLa8try2vLa8tL5YXy4vlxfJiebG8WF4sL5YXy+vL68vry+vL68vry+vL68vry+vLk20jhCiEEpUwwolGBIEsyJKyZBRCiUoYkXLJaEQQfUXZCCEKoUQljEAuyAW5ICuyIiuyIiuyIiuyIiuyIlfkilyRK3JFrsgVuSJX5IpsyIZsyIZsyIZsyIZsyIbsyI7syI7syI7syI7syPspG3cb2Y/ZHkIUQomUa0bKlpGyZzQiiJTHfUX2A7eHEIVQIuXIMMKJRgTRV+xHbw8hCqEEckfuyB25I/cll20jhCiEEpUwwolGBIEsyIIsyIIsyIIsyIIsyIJckAtyQS7IBbkgF+SCXJALsiIrsiIrsiIrsiIr8n4Ge0ZfsZ/BPYQoxJDLllEJI5xoRBB9RZ7BGUIUAtmQDdmQDdmQDdmRHdmRHdmRHdmRHdmRHbkhN+SG3JAbckNuyA25ITfkQA7kQA7kQA7kQA7kQA7kjtyRO3JH7sgdOc9gycehPIMzgugzNM/gjJT3p6VCKFEJI5xoRBB9RZ7BGciCnGew5NNXnsEZRqScT115BmcE0VfkGSyWIUQhlKiEESl7RiOC6Cv2R8U9Um4ZKUeGEpUwwomUe0YQfUWewRlCFEKJShjhBHJFrsiGbMiGbMiGbMiGbMiGbMiO7MiO7MiO7MiO7MiO7MgNuSE35IbckBtyQ27IDbkhB3IgB3IgB3IgB3IgB3Igd+Q8g7plFEKJShgxZM3zlWdwRhB9Rs0zOEOIQihRCSOcaEQQyIIsyIIsyIIsyIIsyIIsyAW5IBfkglyQC3JBLsgFuSArsiIrsiIrsiIrsiIrsiJX5IpckStyRa7IFbkiV+SKnGdQS4YQhVAiZc0wwolGBNFX5BmcIUQhlEB2ZEfOM6g1I4i+Is/gDCEKoUQljHACuSE35EAO5EAO5EAO5EAO5EAO5I7ckTtyR+7IHbkjd+SO3Jds20YIUQglKmGEE40IAlmQBVmQBVmQBVmQBVmQBXk/g5YhRCFStvf3mxMvp3x5vZzP+WrKH6+vjFddXu4u56fX0+3T2+Pjzemfu8e3/R/9fLl72ufr3WW8d9zJzk/fxhzg94fHc9b7ze/t7f9Xx4/Ta3n8ZPyxbof225H9PKBzX+O6/VqP7PdY++Nnmev2RQ7sl3z4mft67f6R66/5yLbv66H/XyU+9suV+0c+/+Npin336/bbkY+/KtdvfNs6su+cn3HHP7IfH/vRr9vvR75+TDh/JlfuFz2yr439eu3+ketnzs3X/MjXjzXOr4VcuX/k4/eP+7dvV+6LHdlXrp8fun//uX/o43c+/970yv0j9y/vXL+2bVfuH7n/tcL1a6Vct6965f7f1+/zeOvu/uHy12+c3lO6PNx9fTyvN7+/Pd3/8d7Xf194D7+xerk835+/vV3OKf3+tVU++H2y8e3TdPucr+Pnm+Nubuqf3/O//w8=", + "debug_symbols": "rdnNTlxHEEDhd5k1i9vd9dPNq0SWhfHYQkKAxhApsnj3dN2ug+1FNneySR1C6gtgFzMMP09fz1/evn9+ePr2/ON0+9fP05fLw+Pjw/fPj8/3d68Pz0/z3/48bfGPWk635eZU6xptDVlD17A1/HRb5+hrjH20bY2yxlTaHFOROWQNXcPW8DWmonNMxW5Osq1R1qhrTMXnmEqfQ9ewNXyNqYw5plK2m5NuOUvOmrPllJya03J6zp4zPUvP0rPw5lfCWk7JqTktp+fsOceavuUsOdPz9Dw9T8/T8/Q8PU+vp9fT6+n19Hp6Pb2eXk+vp9fTG+mN9EZ6I72R3khvpDfSG+mN9Mq2EYWoRCOEUMIIJzqBXJALckEuyAW5IBfkglyQC3INuUYUohKNECLkFmGEEyFLxMiIW1kRskZUohEhW4QSRjjRiZDniZS4nxWFqEQjhFDCCCc6gazIiqzIiqzIiqzIiqzIimzIhmzIhmzIhmzIhmzIhuzIjuzIjuzIjuzIjuzIjtyRO3JH7sgduSN35I7ckTvyQB7IA3kg7+fXI5QwwolOhDy/N9b9BvcoRCUaIYQSRjjRCeSCXJALckEuyAW5IBfkglyQK3JFrsgVuSJX5IpckStyRW7IDbkhN+SG3JAbckNuyA1ZkAVZkAVZkAVZkAVZkAVZkRVZkRVZkRVZkRU5brBuESMjbnBFISox5bo/+AuhhBFOdGJkxA2uKEQlkB05brDGc4q4wRVOhNwiRkbc4IpCVCJkiRBCCSOc6MTIiBtcUYiQNaIRQihhRMgW0YmxosUNrihEyB7RCCGUMCLkHtGJkRE3uCLkEVGJRgihxJTbFuFEJ0ZG3OCKQlSiEUIogVyRK3JFbsgNuSE35IbckBtyQ27IDVmQBVmQBVmQBVmQBVmQBVmRFVmRFVmRFVmRFVmRFdmQDdmQDdmQDdmQDdmQDdmR4wZbiahEI4RQIuR4Lh83uKITIyNucEUhKtEIIZRA7sgduSMP5IE8kAfyQB7IA3kgD+SRsmwbUYhKNEIIJYxwohPIBbkgF+SCXJALckEuyAW5IFfkilyRK3JFrsgVuSJX5IrckPcbbBGVaIQQSoQsEU50ImSNH9c2ohCVaITk1n6DeyALsiDvNxg/D+43uEchKtEIIZQwwolOIBuyIRuyIRuyIRuyIRuyITuyIzuyIzuyIzuyIzuyI3fkjtyRO3JH7sgduSN35I48kAfyQB7IA3kgD+SBPJBHyrptRCEq0QghlDDCiZA9YmTsN7hHIULuEY0QQgkjnOjEyNhvcI9CIFfkirzf4IgwwolOjIz9BvcoRCUaIQRyQ27IDbkhC7IgC7IgC7IgC7IgC7IgK7IiK7IiK7IiK7IiK7IiG7IhG7IhG7IhG7IhG7IhO7IjO7IjO7IjO7IjO3LcoOyvF21EIWrE+/vNiZfaPr9ezud4pe23197mK3Ivd5fz0+vp9unt8fHm9Pfd49v+H/14uXva5+vdZb53kuenr3NO8NvD4znq/ebX9vbfq/OFlVyer5F8rOuh/X5kPx5e1n4b1+2LHtkfI/fnT7XX7Zd6YL/G8/y1367dP/L1b/FDyb4/n1Vfue9H9sv42O/X7Ysc2J9P3XJ/Pgs7st/4/OcTmCP7+rFv5cr9I/cznwWw36/cH0fuZz425/58vL1uvx75+unH94/5IHpkX5x9bdft23Zk3z8+/37o83f53/aP3L9tPfft0P3ZVj/25cr9I3//rfHnZ9Ku3D/y/c+M+zPfrty3I/uDj98PPX7+tl+OfPwu/P139ev27cifn/vHx+/juv1u1+2PP+/303zr7v7h8sdvc99DujzcfXk855vf3p7uf3vv6z8vvIffBr9cnu/PX98u55B+/Uo4fpb6S7vcaB+f4ldj8eZoNzr003v87/8F", "file_map": { "50": { - "source": "fn main(x: u64, y: u8, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176, superseded by issue #8791\n assert(u >> (x as u8) == -1);\n assert(z >> (x as u8) == -1);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n\n assert(z >> 16 == -1);\n assert(-z >> x as u8 == 0);\n}\n", + "source": "fn main(x: u64, y: u64, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176, superseded by issue #8791\n assert(u >> (x as i64 - 2) == -1);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> a == 32);\n a = -a;\n assert(a << 6 == -64);\n assert(a << -a == -2);\n\n assert(x >> (x - 1) == 0);\n\n assert_eq(z >> 3, -97);\n\n assert(z >> 14 == -1);\n let rhs = (if x as i16 > 14 { 14 } else { x as i16 });\n assert(z >> rhs == -1);\n assert(-z >> rhs == 0);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 267c78de544..ff0ca849d90 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -21,7 +21,7 @@ expression: artifact "type": { "kind": "integer", "sign": "unsigned", - "width": 8 + "width": 64 }, "visibility": "private" }, @@ -68,12 +68,12 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ], EXPR [ (1, _2) 0 ], EXPR [ (1, _3) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32840 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U64) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U8) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U16) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U64) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Mov { destination: Relative(3), source: Direct(32838) }, Mov { destination: Relative(4), source: Direct(32839) }, Call { location: 19 }, Call { location: 20 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 525 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 64 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(8), location: 28 }, Call { location: 531 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 128 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 33 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, BinaryIntOp { destination: Relative(6), op: Shr, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(8), location: 39 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 64 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 44 }, Call { location: 531 }, Const { destination: Relative(6), bit_size: Integer(U64), value: 128 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 49 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(5), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U64), value: 32 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 55 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Cast { destination: Relative(6), source: Relative(1), bit_size: Integer(U8) }, Cast { destination: Relative(5), source: Relative(6), bit_size: Integer(U64) }, Cast { destination: Relative(6), source: Relative(5), bit_size: Integer(U8) }, Const { destination: Relative(10), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U64, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 62 }, Jump { location: 109 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 64 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(12) }, JumpIf { condition: Relative(11), location: 66 }, Jump { location: 106 }, Const { destination: Relative(13), bit_size: Integer(U64), value: 1 }, Const { destination: Relative(14), bit_size: Integer(U64), value: 2 }, Const { destination: Relative(15), bit_size: Integer(U64), value: 1 }, Cast { destination: Relative(16), source: Relative(6), bit_size: Integer(U32) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Relative(16) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 77 }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Jump { location: 71 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(13) }, Const { destination: Relative(22), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U64, lhs: Relative(22), rhs: Relative(8) }, Const { destination: Relative(23), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(24), op: Sub, bit_size: U64, lhs: Relative(23), rhs: Relative(8) }, JumpIf { condition: Relative(17), location: 84 }, Jump { location: 86 }, Mov { destination: Relative(18), source: Relative(24) }, Jump { location: 88 }, Mov { destination: Relative(18), source: Relative(8) }, Jump { location: 88 }, Const { destination: Relative(22), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U64, lhs: Relative(22), rhs: Relative(15) }, Const { destination: Relative(23), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(24), op: Sub, bit_size: U64, lhs: Relative(23), rhs: Relative(15) }, JumpIf { condition: Relative(19), location: 94 }, Jump { location: 96 }, Mov { destination: Relative(20), source: Relative(24) }, Jump { location: 98 }, Mov { destination: Relative(20), source: Relative(15) }, Jump { location: 98 }, BinaryIntOp { destination: Relative(8), op: Div, bit_size: U64, lhs: Relative(18), rhs: Relative(20) }, BinaryIntOp { destination: Relative(21), op: Xor, bit_size: U1, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(21), location: 102 }, Jump { location: 104 }, Const { destination: Relative(22), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U64, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U64, lhs: Relative(8), rhs: Relative(13) }, Jump { location: 108 }, Const { destination: Relative(8), bit_size: Integer(U64), value: 18446744073709551615 }, Jump { location: 108 }, Jump { location: 111 }, BinaryIntOp { destination: Relative(8), op: Shr, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, Jump { location: 111 }, Const { destination: Relative(4), bit_size: Integer(U64), value: 18446744073709551615 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U64, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 116 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, Const { destination: Relative(9), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U16, lhs: Relative(9), rhs: Relative(3) }, JumpIf { condition: Relative(8), location: 120 }, Jump { location: 167 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(13) }, JumpIf { condition: Relative(11), location: 124 }, Jump { location: 164 }, Const { destination: Relative(14), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(15), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(16), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(17), source: Relative(6), bit_size: Integer(U32) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(17) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 135 }, BinaryIntOp { destination: Relative(16), op: Mul, bit_size: U16, lhs: Relative(16), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Jump { location: 129 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(14) }, Const { destination: Relative(23), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U16, lhs: Relative(23), rhs: Relative(4) }, Const { destination: Relative(24), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(25), op: Sub, bit_size: U16, lhs: Relative(24), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 142 }, Jump { location: 144 }, Mov { destination: Relative(19), source: Relative(25) }, Jump { location: 146 }, Mov { destination: Relative(19), source: Relative(4) }, Jump { location: 146 }, Const { destination: Relative(23), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U16, lhs: Relative(23), rhs: Relative(16) }, Const { destination: Relative(24), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(25), op: Sub, bit_size: U16, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(20), location: 152 }, Jump { location: 154 }, Mov { destination: Relative(21), source: Relative(25) }, Jump { location: 156 }, Mov { destination: Relative(21), source: Relative(16) }, Jump { location: 156 }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U16, lhs: Relative(19), rhs: Relative(21) }, BinaryIntOp { destination: Relative(22), op: Xor, bit_size: U1, lhs: Relative(18), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 160 }, Jump { location: 162 }, Const { destination: Relative(23), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(23), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(4), rhs: Relative(14) }, Jump { location: 166 }, Const { destination: Relative(4), bit_size: Integer(U16), value: 65535 }, Jump { location: 166 }, Jump { location: 169 }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(6) }, Jump { location: 169 }, Const { destination: Relative(8), bit_size: Integer(U16), value: 65535 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U16, lhs: Relative(4), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Cast { destination: Relative(4), source: Relative(2), bit_size: Integer(U8) }, Cast { destination: Relative(11), source: Relative(5), bit_size: Integer(U8) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(14), op: Shl, bit_size: U8, lhs: Relative(11), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(14) }, Const { destination: Relative(14), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(14) }, JumpIf { condition: Relative(15), location: 184 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Const { destination: Relative(5), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U8, lhs: Relative(17), rhs: Relative(11) }, JumpIf { condition: Relative(16), location: 189 }, Jump { location: 236 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U8, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(18), location: 193 }, Jump { location: 233 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 1 }, Cast { destination: Relative(23), source: Relative(5), bit_size: Integer(U32) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U32, lhs: Relative(24), rhs: Relative(23) }, Not { destination: Relative(25), source: Relative(25), bit_size: U1 }, JumpIf { condition: Relative(25), location: 204 }, BinaryIntOp { destination: Relative(22), op: Mul, bit_size: U8, lhs: Relative(22), rhs: Relative(21) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Jump { location: 198 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U8, lhs: Relative(11), rhs: Relative(20) }, Const { destination: Relative(29), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U8, lhs: Relative(29), rhs: Relative(15) }, Const { destination: Relative(30), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(31), op: Sub, bit_size: U8, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(24), location: 211 }, Jump { location: 213 }, Mov { destination: Relative(25), source: Relative(31) }, Jump { location: 215 }, Mov { destination: Relative(25), source: Relative(15) }, Jump { location: 215 }, Const { destination: Relative(29), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U8, lhs: Relative(29), rhs: Relative(22) }, Const { destination: Relative(30), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(31), op: Sub, bit_size: U8, lhs: Relative(30), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 221 }, Jump { location: 223 }, Mov { destination: Relative(27), source: Relative(31) }, Jump { location: 225 }, Mov { destination: Relative(27), source: Relative(22) }, Jump { location: 225 }, BinaryIntOp { destination: Relative(15), op: Div, bit_size: U8, lhs: Relative(25), rhs: Relative(27) }, BinaryIntOp { destination: Relative(28), op: Xor, bit_size: U1, lhs: Relative(24), rhs: Relative(26) }, JumpIf { condition: Relative(28), location: 229 }, Jump { location: 231 }, Const { destination: Relative(29), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U8, lhs: Relative(29), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U8, lhs: Relative(15), rhs: Relative(20) }, Jump { location: 235 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 255 }, Jump { location: 235 }, Jump { location: 238 }, BinaryIntOp { destination: Relative(15), op: Shr, bit_size: U8, lhs: Relative(11), rhs: Relative(5) }, Jump { location: 238 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U8, lhs: Relative(15), rhs: Relative(5) }, JumpIf { condition: Relative(16), location: 243 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(16), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U8, lhs: Relative(16), rhs: Relative(11) }, JumpIf { condition: Relative(15), location: 247 }, Jump { location: 294 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 251 }, Jump { location: 291 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 1 }, Cast { destination: Relative(24), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(25), rhs: Relative(24) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 262 }, BinaryIntOp { destination: Relative(23), op: Mul, bit_size: U8, lhs: Relative(23), rhs: Relative(22) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Jump { location: 256 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U8, lhs: Relative(11), rhs: Relative(21) }, Const { destination: Relative(30), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U8, lhs: Relative(30), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U8, lhs: Relative(31), rhs: Relative(5) }, JumpIf { condition: Relative(25), location: 269 }, Jump { location: 271 }, Mov { destination: Relative(26), source: Relative(32) }, Jump { location: 273 }, Mov { destination: Relative(26), source: Relative(5) }, Jump { location: 273 }, Const { destination: Relative(30), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U8, lhs: Relative(30), rhs: Relative(23) }, Const { destination: Relative(31), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U8, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(27), location: 279 }, Jump { location: 281 }, Mov { destination: Relative(28), source: Relative(32) }, Jump { location: 283 }, Mov { destination: Relative(28), source: Relative(23) }, Jump { location: 283 }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U8, lhs: Relative(26), rhs: Relative(28) }, BinaryIntOp { destination: Relative(29), op: Xor, bit_size: U1, lhs: Relative(25), rhs: Relative(27) }, JumpIf { condition: Relative(29), location: 287 }, Jump { location: 289 }, Const { destination: Relative(30), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U8, lhs: Relative(30), rhs: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U8, lhs: Relative(5), rhs: Relative(21) }, Jump { location: 293 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 255 }, Jump { location: 293 }, Jump { location: 296 }, BinaryIntOp { destination: Relative(5), op: Shr, bit_size: U8, lhs: Relative(11), rhs: Relative(2) }, Jump { location: 296 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(15), location: 301 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(5), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U8, lhs: Relative(5), rhs: Relative(4) }, Mov { destination: Relative(4), source: Relative(11) }, Cast { destination: Relative(5), source: Relative(4), bit_size: Integer(U8) }, Const { destination: Relative(11), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(11) }, Not { destination: Relative(18), source: Relative(15), bit_size: U1 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U8, lhs: Relative(5), rhs: Relative(11) }, BinaryIntOp { destination: Relative(5), op: Mul, bit_size: U1, lhs: Relative(15), rhs: Relative(18) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U1, lhs: Relative(5), rhs: Relative(18) }, JumpIf { condition: Relative(11), location: 313 }, Call { location: 534 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 7 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U8, lhs: Relative(4), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(14) }, JumpIf { condition: Relative(11), location: 320 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U8, lhs: Relative(4), rhs: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(11), location: 325 }, Call { location: 531 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 254 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U8, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 331 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U64, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 337 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U16, lhs: Relative(5), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 342 }, Jump { location: 389 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U8, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(7), location: 346 }, Jump { location: 386 }, Const { destination: Relative(14), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(15), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(18), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(21), source: Relative(1), bit_size: Integer(U32) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 357 }, BinaryIntOp { destination: Relative(18), op: Mul, bit_size: U16, lhs: Relative(18), rhs: Relative(15) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Jump { location: 351 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(14) }, Const { destination: Relative(27), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U16, lhs: Relative(27), rhs: Relative(2) }, Const { destination: Relative(28), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U16, lhs: Relative(28), rhs: Relative(2) }, JumpIf { condition: Relative(22), location: 364 }, Jump { location: 366 }, Mov { destination: Relative(23), source: Relative(29) }, Jump { location: 368 }, Mov { destination: Relative(23), source: Relative(2) }, Jump { location: 368 }, Const { destination: Relative(27), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U16, lhs: Relative(27), rhs: Relative(18) }, Const { destination: Relative(28), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U16, lhs: Relative(28), rhs: Relative(18) }, JumpIf { condition: Relative(24), location: 374 }, Jump { location: 376 }, Mov { destination: Relative(25), source: Relative(29) }, Jump { location: 378 }, Mov { destination: Relative(25), source: Relative(18) }, Jump { location: 378 }, BinaryIntOp { destination: Relative(2), op: Div, bit_size: U16, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(26), op: Xor, bit_size: U1, lhs: Relative(22), rhs: Relative(24) }, JumpIf { condition: Relative(26), location: 382 }, Jump { location: 384 }, Const { destination: Relative(27), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(27), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(2), rhs: Relative(14) }, Jump { location: 388 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65535 }, Jump { location: 388 }, Jump { location: 391 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, Jump { location: 391 }, Const { destination: Relative(1), bit_size: Integer(U16), value: 65439 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 396 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 16 }, Const { destination: Relative(7), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U16, lhs: Relative(7), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 401 }, Jump { location: 448 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U8, lhs: Relative(1), rhs: Relative(15) }, JumpIf { condition: Relative(14), location: 405 }, Jump { location: 445 }, Const { destination: Relative(18), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(21), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(22), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(23), source: Relative(1), bit_size: Integer(U32) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U32, lhs: Relative(24), rhs: Relative(23) }, Not { destination: Relative(25), source: Relative(25), bit_size: U1 }, JumpIf { condition: Relative(25), location: 416 }, BinaryIntOp { destination: Relative(22), op: Mul, bit_size: U16, lhs: Relative(22), rhs: Relative(21) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Jump { location: 410 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(18) }, Const { destination: Relative(29), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U16, lhs: Relative(29), rhs: Relative(2) }, Const { destination: Relative(30), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(31), op: Sub, bit_size: U16, lhs: Relative(30), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 423 }, Jump { location: 425 }, Mov { destination: Relative(25), source: Relative(31) }, Jump { location: 427 }, Mov { destination: Relative(25), source: Relative(2) }, Jump { location: 427 }, Const { destination: Relative(29), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U16, lhs: Relative(29), rhs: Relative(22) }, Const { destination: Relative(30), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(31), op: Sub, bit_size: U16, lhs: Relative(30), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 433 }, Jump { location: 435 }, Mov { destination: Relative(27), source: Relative(31) }, Jump { location: 437 }, Mov { destination: Relative(27), source: Relative(22) }, Jump { location: 437 }, BinaryIntOp { destination: Relative(2), op: Div, bit_size: U16, lhs: Relative(25), rhs: Relative(27) }, BinaryIntOp { destination: Relative(28), op: Xor, bit_size: U1, lhs: Relative(24), rhs: Relative(26) }, JumpIf { condition: Relative(28), location: 441 }, Jump { location: 443 }, Const { destination: Relative(29), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(29), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(2), rhs: Relative(18) }, Jump { location: 447 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65535 }, Jump { location: 447 }, Jump { location: 450 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, Jump { location: 450 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(1), location: 454 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(1), rhs: Relative(3) }, Mov { destination: Relative(4), source: Relative(2) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Integer(U16) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Integer(U16) }, Const { destination: Relative(3), bit_size: Integer(U16), value: 32768 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U16, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(14), bit_size: U1 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U16, lhs: Relative(2), rhs: Relative(3) }, BinaryIntOp { destination: Relative(2), op: Mul, bit_size: U1, lhs: Relative(14), rhs: Relative(8) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(3), location: 467 }, Call { location: 534 }, Const { destination: Relative(8), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U16, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(3), location: 471 }, Jump { location: 518 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(18) }, JumpIf { condition: Relative(14), location: 475 }, Jump { location: 515 }, Const { destination: Relative(21), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(22), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(23), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(24), source: Relative(6), bit_size: Integer(U32) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(25), rhs: Relative(24) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 486 }, BinaryIntOp { destination: Relative(23), op: Mul, bit_size: U16, lhs: Relative(23), rhs: Relative(22) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Jump { location: 480 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U16, lhs: Relative(4), rhs: Relative(21) }, Const { destination: Relative(30), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U16, lhs: Relative(30), rhs: Relative(2) }, Const { destination: Relative(31), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U16, lhs: Relative(31), rhs: Relative(2) }, JumpIf { condition: Relative(25), location: 493 }, Jump { location: 495 }, Mov { destination: Relative(26), source: Relative(32) }, Jump { location: 497 }, Mov { destination: Relative(26), source: Relative(2) }, Jump { location: 497 }, Const { destination: Relative(30), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U16, lhs: Relative(30), rhs: Relative(23) }, Const { destination: Relative(31), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U16, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(27), location: 503 }, Jump { location: 505 }, Mov { destination: Relative(28), source: Relative(32) }, Jump { location: 507 }, Mov { destination: Relative(28), source: Relative(23) }, Jump { location: 507 }, BinaryIntOp { destination: Relative(2), op: Div, bit_size: U16, lhs: Relative(26), rhs: Relative(28) }, BinaryIntOp { destination: Relative(29), op: Xor, bit_size: U1, lhs: Relative(25), rhs: Relative(27) }, JumpIf { condition: Relative(29), location: 511 }, Jump { location: 513 }, Const { destination: Relative(30), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(30), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(2), rhs: Relative(21) }, Jump { location: 517 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65535 }, Jump { location: 517 }, Jump { location: 520 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(4), rhs: Relative(6) }, Jump { location: 520 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 524 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 530 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32840 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U64) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U64) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U16) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U64) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Mov { destination: Relative(3), source: Direct(32838) }, Mov { destination: Relative(4), source: Direct(32839) }, Call { location: 19 }, Call { location: 20 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 584 }, Const { destination: Relative(5), bit_size: Integer(U64), value: 64 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U64, lhs: Relative(2), rhs: Relative(5) }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 26 }, Call { location: 590 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U64), value: 128 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U64, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 32 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, BinaryIntOp { destination: Relative(6), op: Shr, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(9), bit_size: Integer(U64), value: 32 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U64, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(10), location: 38 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U64, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(10), location: 43 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, BinaryIntOp { destination: Relative(6), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U64, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(8), location: 48 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Cast { destination: Relative(6), source: Relative(1), bit_size: Integer(U64) }, Const { destination: Relative(8), bit_size: Integer(U64), value: 2 }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U64, lhs: Relative(6), rhs: Relative(8) }, Mov { destination: Relative(6), source: Relative(9) }, Cast { destination: Relative(8), source: Relative(6), bit_size: Integer(U64) }, Const { destination: Relative(9), bit_size: Integer(U64), value: 9223372036854775808 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U64, lhs: Relative(1), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(10), bit_size: U1 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U64, lhs: Relative(8), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(12), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U1, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(9), location: 62 }, Call { location: 593 }, Const { destination: Relative(9), bit_size: Integer(U64), value: 63 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U64, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(10), location: 66 }, Call { location: 590 }, Const { destination: Relative(10), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U64, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 70 }, Jump { location: 117 }, Const { destination: Relative(12), bit_size: Integer(U64), value: 64 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U64, lhs: Relative(6), rhs: Relative(12) }, JumpIf { condition: Relative(11), location: 74 }, Jump { location: 114 }, Const { destination: Relative(13), bit_size: Integer(U64), value: 1 }, Const { destination: Relative(14), bit_size: Integer(U64), value: 2 }, Const { destination: Relative(15), bit_size: Integer(U64), value: 1 }, Cast { destination: Relative(16), source: Relative(6), bit_size: Integer(U32) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Relative(16) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 85 }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Jump { location: 79 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(13) }, Const { destination: Relative(22), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U64, lhs: Relative(22), rhs: Relative(8) }, Const { destination: Relative(23), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(24), op: Sub, bit_size: U64, lhs: Relative(23), rhs: Relative(8) }, JumpIf { condition: Relative(17), location: 92 }, Jump { location: 94 }, Mov { destination: Relative(18), source: Relative(24) }, Jump { location: 96 }, Mov { destination: Relative(18), source: Relative(8) }, Jump { location: 96 }, Const { destination: Relative(22), bit_size: Integer(U64), value: 9223372036854775807 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U64, lhs: Relative(22), rhs: Relative(15) }, Const { destination: Relative(23), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(24), op: Sub, bit_size: U64, lhs: Relative(23), rhs: Relative(15) }, JumpIf { condition: Relative(19), location: 102 }, Jump { location: 104 }, Mov { destination: Relative(20), source: Relative(24) }, Jump { location: 106 }, Mov { destination: Relative(20), source: Relative(15) }, Jump { location: 106 }, BinaryIntOp { destination: Relative(8), op: Div, bit_size: U64, lhs: Relative(18), rhs: Relative(20) }, BinaryIntOp { destination: Relative(21), op: Xor, bit_size: U1, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(21), location: 110 }, Jump { location: 112 }, Const { destination: Relative(22), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U64, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U64, lhs: Relative(8), rhs: Relative(13) }, Jump { location: 116 }, Const { destination: Relative(8), bit_size: Integer(U64), value: 18446744073709551615 }, Jump { location: 116 }, Jump { location: 119 }, BinaryIntOp { destination: Relative(8), op: Shr, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, Jump { location: 119 }, Mov { destination: Relative(4), source: Relative(8) }, Const { destination: Relative(6), bit_size: Integer(U64), value: 18446744073709551615 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 125 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Cast { destination: Relative(6), source: Relative(2), bit_size: Integer(U8) }, Cast { destination: Relative(4), source: Relative(6), bit_size: Integer(U64) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Integer(U8) }, Cast { destination: Relative(8), source: Relative(1), bit_size: Integer(U8) }, Cast { destination: Relative(6), source: Relative(8), bit_size: Integer(U64) }, Cast { destination: Relative(8), source: Relative(6), bit_size: Integer(U8) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(9), op: Shl, bit_size: U8, lhs: Relative(8), rhs: Relative(6) }, Mov { destination: Relative(6), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 139 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(6), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U8, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 144 }, Jump { location: 191 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(15) }, JumpIf { condition: Relative(14), location: 148 }, Jump { location: 188 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 1 }, Cast { destination: Relative(19), source: Relative(6), bit_size: Integer(U32) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(19) }, Not { destination: Relative(21), source: Relative(21), bit_size: U1 }, JumpIf { condition: Relative(21), location: 159 }, BinaryIntOp { destination: Relative(18), op: Mul, bit_size: U8, lhs: Relative(18), rhs: Relative(17) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Jump { location: 153 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U8, lhs: Relative(8), rhs: Relative(16) }, Const { destination: Relative(25), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U8, lhs: Relative(25), rhs: Relative(9) }, Const { destination: Relative(26), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(27), op: Sub, bit_size: U8, lhs: Relative(26), rhs: Relative(9) }, JumpIf { condition: Relative(20), location: 166 }, Jump { location: 168 }, Mov { destination: Relative(21), source: Relative(27) }, Jump { location: 170 }, Mov { destination: Relative(21), source: Relative(9) }, Jump { location: 170 }, Const { destination: Relative(25), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U8, lhs: Relative(25), rhs: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(27), op: Sub, bit_size: U8, lhs: Relative(26), rhs: Relative(18) }, JumpIf { condition: Relative(22), location: 176 }, Jump { location: 178 }, Mov { destination: Relative(23), source: Relative(27) }, Jump { location: 180 }, Mov { destination: Relative(23), source: Relative(18) }, Jump { location: 180 }, BinaryIntOp { destination: Relative(9), op: Div, bit_size: U8, lhs: Relative(21), rhs: Relative(23) }, BinaryIntOp { destination: Relative(24), op: Xor, bit_size: U1, lhs: Relative(20), rhs: Relative(22) }, JumpIf { condition: Relative(24), location: 184 }, Jump { location: 186 }, Const { destination: Relative(25), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U8, lhs: Relative(25), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U8, lhs: Relative(9), rhs: Relative(16) }, Jump { location: 190 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 255 }, Jump { location: 190 }, Jump { location: 193 }, BinaryIntOp { destination: Relative(9), op: Shr, bit_size: U8, lhs: Relative(8), rhs: Relative(6) }, Jump { location: 193 }, Mov { destination: Relative(6), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 199 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Cast { destination: Relative(6), source: Relative(4), bit_size: Integer(U8) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 7 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 204 }, Call { location: 590 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U8, lhs: Relative(14), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 208 }, Jump { location: 255 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U8, lhs: Relative(2), rhs: Relative(17) }, JumpIf { condition: Relative(16), location: 212 }, Jump { location: 252 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 2 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 1 }, Cast { destination: Relative(21), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 223 }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U8, lhs: Relative(20), rhs: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Jump { location: 217 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U8, lhs: Relative(8), rhs: Relative(18) }, Const { destination: Relative(27), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U8, lhs: Relative(27), rhs: Relative(9) }, Const { destination: Relative(28), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U8, lhs: Relative(28), rhs: Relative(9) }, JumpIf { condition: Relative(22), location: 230 }, Jump { location: 232 }, Mov { destination: Relative(23), source: Relative(29) }, Jump { location: 234 }, Mov { destination: Relative(23), source: Relative(9) }, Jump { location: 234 }, Const { destination: Relative(27), bit_size: Integer(U8), value: 127 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U8, lhs: Relative(27), rhs: Relative(20) }, Const { destination: Relative(28), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U8, lhs: Relative(28), rhs: Relative(20) }, JumpIf { condition: Relative(24), location: 240 }, Jump { location: 242 }, Mov { destination: Relative(25), source: Relative(29) }, Jump { location: 244 }, Mov { destination: Relative(25), source: Relative(20) }, Jump { location: 244 }, BinaryIntOp { destination: Relative(9), op: Div, bit_size: U8, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(26), op: Xor, bit_size: U1, lhs: Relative(22), rhs: Relative(24) }, JumpIf { condition: Relative(26), location: 248 }, Jump { location: 250 }, Const { destination: Relative(27), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U8, lhs: Relative(27), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U8, lhs: Relative(9), rhs: Relative(18) }, Jump { location: 254 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 255 }, Jump { location: 254 }, Jump { location: 257 }, BinaryIntOp { destination: Relative(9), op: Shr, bit_size: U8, lhs: Relative(8), rhs: Relative(2) }, Jump { location: 257 }, Mov { destination: Relative(8), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 263 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Const { destination: Relative(8), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U8, lhs: Relative(8), rhs: Relative(2) }, Mov { destination: Relative(2), source: Relative(9) }, Cast { destination: Relative(9), source: Relative(2), bit_size: Integer(U8) }, Const { destination: Relative(11), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(11) }, Not { destination: Relative(6), source: Relative(16), bit_size: U1 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U8, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(9), op: Mul, bit_size: U1, lhs: Relative(16), rhs: Relative(6) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(6) }, JumpIf { condition: Relative(18), location: 275 }, Call { location: 593 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 6 }, BinaryIntOp { destination: Relative(9), op: Shl, bit_size: U8, lhs: Relative(2), rhs: Relative(6) }, Mov { destination: Relative(6), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U8), value: 192 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(18), location: 283 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U8, lhs: Relative(8), rhs: Relative(2) }, Mov { destination: Relative(8), source: Relative(6) }, Cast { destination: Relative(6), source: Relative(8), bit_size: Integer(U8) }, Not { destination: Relative(9), source: Relative(16), bit_size: U1 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Mul, bit_size: U1, lhs: Relative(16), rhs: Relative(9) }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U1, lhs: Relative(11), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 292 }, Call { location: 593 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 295 }, Call { location: 590 }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U8, lhs: Relative(2), rhs: Relative(8) }, Mov { destination: Relative(2), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 254 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U8, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 302 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(2), bit_size: Integer(U64), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U64, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 307 }, Call { location: 593 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(2), location: 310 }, Call { location: 590 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U64, lhs: Relative(1), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 316 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Const { destination: Relative(2), bit_size: Integer(U16), value: 3 }, Const { destination: Relative(6), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U16, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 321 }, Jump { location: 368 }, Const { destination: Relative(9), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U16, lhs: Relative(2), rhs: Relative(9) }, JumpIf { condition: Relative(8), location: 325 }, Jump { location: 365 }, Const { destination: Relative(11), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(16), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(18), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(19), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(19) }, Not { destination: Relative(21), source: Relative(21), bit_size: U1 }, JumpIf { condition: Relative(21), location: 336 }, BinaryIntOp { destination: Relative(18), op: Mul, bit_size: U16, lhs: Relative(18), rhs: Relative(16) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Jump { location: 330 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(11) }, Const { destination: Relative(25), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U16, lhs: Relative(25), rhs: Relative(4) }, Const { destination: Relative(26), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(27), op: Sub, bit_size: U16, lhs: Relative(26), rhs: Relative(4) }, JumpIf { condition: Relative(20), location: 343 }, Jump { location: 345 }, Mov { destination: Relative(21), source: Relative(27) }, Jump { location: 347 }, Mov { destination: Relative(21), source: Relative(4) }, Jump { location: 347 }, Const { destination: Relative(25), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U16, lhs: Relative(25), rhs: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(27), op: Sub, bit_size: U16, lhs: Relative(26), rhs: Relative(18) }, JumpIf { condition: Relative(22), location: 353 }, Jump { location: 355 }, Mov { destination: Relative(23), source: Relative(27) }, Jump { location: 357 }, Mov { destination: Relative(23), source: Relative(18) }, Jump { location: 357 }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U16, lhs: Relative(21), rhs: Relative(23) }, BinaryIntOp { destination: Relative(24), op: Xor, bit_size: U1, lhs: Relative(20), rhs: Relative(22) }, JumpIf { condition: Relative(24), location: 361 }, Jump { location: 363 }, Const { destination: Relative(25), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(25), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(4), rhs: Relative(11) }, Jump { location: 367 }, Const { destination: Relative(4), bit_size: Integer(U16), value: 65535 }, Jump { location: 367 }, Jump { location: 370 }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(2) }, Jump { location: 370 }, Mov { destination: Relative(2), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U16), value: 65439 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 376 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(2), bit_size: Integer(U16), value: 14 }, Const { destination: Relative(8), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U16, lhs: Relative(8), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 381 }, Jump { location: 428 }, Const { destination: Relative(16), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U16, lhs: Relative(2), rhs: Relative(16) }, JumpIf { condition: Relative(11), location: 385 }, Jump { location: 425 }, Const { destination: Relative(18), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(19), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(20), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(21), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 396 }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U16, lhs: Relative(20), rhs: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Jump { location: 390 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(18) }, Const { destination: Relative(27), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U16, lhs: Relative(27), rhs: Relative(4) }, Const { destination: Relative(28), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U16, lhs: Relative(28), rhs: Relative(4) }, JumpIf { condition: Relative(22), location: 403 }, Jump { location: 405 }, Mov { destination: Relative(23), source: Relative(29) }, Jump { location: 407 }, Mov { destination: Relative(23), source: Relative(4) }, Jump { location: 407 }, Const { destination: Relative(27), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U16, lhs: Relative(27), rhs: Relative(20) }, Const { destination: Relative(28), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(29), op: Sub, bit_size: U16, lhs: Relative(28), rhs: Relative(20) }, JumpIf { condition: Relative(24), location: 413 }, Jump { location: 415 }, Mov { destination: Relative(25), source: Relative(29) }, Jump { location: 417 }, Mov { destination: Relative(25), source: Relative(20) }, Jump { location: 417 }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U16, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(26), op: Xor, bit_size: U1, lhs: Relative(22), rhs: Relative(24) }, JumpIf { condition: Relative(26), location: 421 }, Jump { location: 423 }, Const { destination: Relative(27), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(27), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(4), rhs: Relative(18) }, Jump { location: 427 }, Const { destination: Relative(4), bit_size: Integer(U16), value: 65535 }, Jump { location: 427 }, Jump { location: 430 }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(2) }, Jump { location: 430 }, Mov { destination: Relative(5), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U16), value: 65535 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U16, lhs: Relative(5), rhs: Relative(4) }, JumpIf { condition: Relative(11), location: 436 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Cast { destination: Relative(11), source: Relative(1), bit_size: Integer(U16) }, Cast { destination: Relative(5), source: Relative(11), bit_size: Integer(U64) }, Cast { destination: Relative(1), source: Relative(5), bit_size: Integer(U16) }, Const { destination: Relative(19), bit_size: Integer(U16), value: 32768 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U16, lhs: Relative(2), rhs: Relative(19) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U16, lhs: Relative(1), rhs: Relative(19) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U16, lhs: Relative(11), rhs: Relative(18) }, Not { destination: Relative(11), source: Relative(5), bit_size: U1 }, Cast { destination: Relative(18), source: Relative(5), bit_size: Integer(U16) }, Cast { destination: Relative(5), source: Relative(11), bit_size: Integer(U16) }, BinaryIntOp { destination: Relative(11), op: Mul, bit_size: U16, lhs: Relative(18), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Mul, bit_size: U16, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U16, lhs: Relative(11), rhs: Relative(2) }, Cast { destination: Relative(2), source: Relative(1), bit_size: Integer(U16) }, Const { destination: Relative(5), bit_size: Integer(U16), value: 15 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U16, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(11), location: 454 }, Call { location: 590 }, Const { destination: Relative(7), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U16, lhs: Relative(7), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 458 }, Jump { location: 505 }, Const { destination: Relative(18), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U16, lhs: Relative(1), rhs: Relative(18) }, JumpIf { condition: Relative(11), location: 462 }, Jump { location: 502 }, Const { destination: Relative(19), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(20), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(21), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(22), source: Relative(1), bit_size: Integer(U32) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(23), rhs: Relative(22) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 473 }, BinaryIntOp { destination: Relative(21), op: Mul, bit_size: U16, lhs: Relative(21), rhs: Relative(20) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Jump { location: 467 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U16, lhs: Relative(3), rhs: Relative(19) }, Const { destination: Relative(28), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U16, lhs: Relative(28), rhs: Relative(2) }, Const { destination: Relative(29), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(30), op: Sub, bit_size: U16, lhs: Relative(29), rhs: Relative(2) }, JumpIf { condition: Relative(23), location: 480 }, Jump { location: 482 }, Mov { destination: Relative(24), source: Relative(30) }, Jump { location: 484 }, Mov { destination: Relative(24), source: Relative(2) }, Jump { location: 484 }, Const { destination: Relative(28), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U16, lhs: Relative(28), rhs: Relative(21) }, Const { destination: Relative(29), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(30), op: Sub, bit_size: U16, lhs: Relative(29), rhs: Relative(21) }, JumpIf { condition: Relative(25), location: 490 }, Jump { location: 492 }, Mov { destination: Relative(26), source: Relative(30) }, Jump { location: 494 }, Mov { destination: Relative(26), source: Relative(21) }, Jump { location: 494 }, BinaryIntOp { destination: Relative(2), op: Div, bit_size: U16, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(27), op: Xor, bit_size: U1, lhs: Relative(23), rhs: Relative(25) }, JumpIf { condition: Relative(27), location: 498 }, Jump { location: 500 }, Const { destination: Relative(28), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(28), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(2), rhs: Relative(19) }, Jump { location: 504 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65535 }, Jump { location: 504 }, Jump { location: 507 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, Jump { location: 507 }, Mov { destination: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U16, lhs: Relative(5), rhs: Relative(4) }, JumpIf { condition: Relative(2), location: 512 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, Const { destination: Relative(2), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(5), source: Relative(4) }, Cast { destination: Relative(4), source: Relative(5), bit_size: Integer(U16) }, Cast { destination: Relative(11), source: Relative(3), bit_size: Integer(U16) }, Const { destination: Relative(3), bit_size: Integer(U16), value: 32768 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U16, lhs: Relative(11), rhs: Relative(3) }, Not { destination: Relative(11), source: Relative(19), bit_size: U1 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U16, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Mul, bit_size: U1, lhs: Relative(19), rhs: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(4), location: 525 }, Call { location: 593 }, Const { destination: Relative(11), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U16, lhs: Relative(11), rhs: Relative(5) }, JumpIf { condition: Relative(4), location: 529 }, Jump { location: 576 }, Const { destination: Relative(20), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U16, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(19), location: 533 }, Jump { location: 573 }, Const { destination: Relative(21), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(22), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(23), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(24), source: Relative(1), bit_size: Integer(U32) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(25), rhs: Relative(24) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 544 }, BinaryIntOp { destination: Relative(23), op: Mul, bit_size: U16, lhs: Relative(23), rhs: Relative(22) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Jump { location: 538 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U16, lhs: Relative(5), rhs: Relative(21) }, Const { destination: Relative(30), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(25), op: LessThan, bit_size: U16, lhs: Relative(30), rhs: Relative(3) }, Const { destination: Relative(31), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U16, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(25), location: 551 }, Jump { location: 553 }, Mov { destination: Relative(26), source: Relative(32) }, Jump { location: 555 }, Mov { destination: Relative(26), source: Relative(3) }, Jump { location: 555 }, Const { destination: Relative(30), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U16, lhs: Relative(30), rhs: Relative(23) }, Const { destination: Relative(31), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(32), op: Sub, bit_size: U16, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(27), location: 561 }, Jump { location: 563 }, Mov { destination: Relative(28), source: Relative(32) }, Jump { location: 565 }, Mov { destination: Relative(28), source: Relative(23) }, Jump { location: 565 }, BinaryIntOp { destination: Relative(3), op: Div, bit_size: U16, lhs: Relative(26), rhs: Relative(28) }, BinaryIntOp { destination: Relative(29), op: Xor, bit_size: U1, lhs: Relative(25), rhs: Relative(27) }, JumpIf { condition: Relative(29), location: 569 }, Jump { location: 571 }, Const { destination: Relative(30), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U16, lhs: Relative(30), rhs: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U16, lhs: Relative(3), rhs: Relative(21) }, Jump { location: 575 }, Const { destination: Relative(3), bit_size: Integer(U16), value: 65535 }, Jump { location: 575 }, Jump { location: 578 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U16, lhs: Relative(5), rhs: Relative(1) }, Jump { location: 578 }, Mov { destination: Relative(1), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 583 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 589 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pdnBThw5EIDhd5kzhy6Xq1zmVaIoImQSISFAE1hpFfHu62r7J8lhLz2X1E9IfUENbprh1+nb+evbjy8PT9+ff55uP/06fb08PD4+/Pjy+Hx/9/rw/DT+9tdpyz+KnG7l5lTKHDpHncPm8DnaHHG6LWP0feg2h8xR5hiKjjGUOobN4XO0OWKOodjNqW5zyBxlDp1jKD6GzeFztDlijqG0m5MNJcaQOcocOkedYyh9DJ+jzTEU2cbsc/q2pqxZ1tQ165q2pq/Z1lyeL68try2vLa8try2vLa8try2vLa8tL5YXy4vlxfJiebG8WF4sL5YXy+vL68vry+vL68vry+vL68vry+vLk20jhCiEEpUwwolGBIEsyJKyZBRCiUoYkXLJaEQQfUXZCCEKoUQljEAuyAW5ICuyIiuyIiuyIiuyIiuyIlfkilyRK3JFrsgVuSJX5IpsyIZsyIZsyIZsyIZsyIbsyI7syI7syI7syI7syPspG3cb2Y/ZHkIUQomUa0bKlpGyZzQiiJTHfUX2A7eHEIVQIuXIMMKJRgTRV+xHbw8hCqEEckfuyB25I/cll20jhCiEEpUwwolGBIEsyIIsyIIsyIIsyIIsyIJckAtyQS7IBbkgF+SCXJALsiIrsiIrsiIrsiIr8n4Ge0ZfsZ/BPYQoxJDLllEJI5xoRBB9RZ7BGUIUAtmQDdmQDdmQDdmRHdmRHdmRHdmRHdmRHbkhN+SG3JAbckNuyA25ITfkQA7kQA7kQA7kQA7kQA7kjtyRO3JH7sgdOc9gycehPIMzgugzNM/gjJT3p6VCKFEJI5xoRBB9RZ7BGciCnGew5NNXnsEZRqScT115BmcE0VfkGSyWIUQhlKiEESl7RiOC6Cv2R8U9Um4ZKUeGEpUwwomUe0YQfUWewRlCFEKJShjhBHJFrsiGbMiGbMiGbMiGbMiGbMiO7MiO7MiO7MiO7MiO7MgNuSE35IbckBtyQ27IDbkhB3IgB3IgB3IgB3IgB3Igd+Q8g7plFEKJShgxZM3zlWdwRhB9Rs0zOEOIQihRCSOcaEQQyIIsyIIsyIIsyIIsyIIsyAW5IBfkglyQC3JBLsgFuSArsiIrsiIrsiIrsiIrsiJX5IpckStyRa7IFbkiV+SKnGdQS4YQhVAiZc0wwolGBNFX5BmcIUQhlEB2ZEfOM6g1I4i+Is/gDCEKoUQljHACuSE35EAO5EAO5EAO5EAO5EAO5I7ckTtyR+7IHbkjd+SO3Jds20YIUQglKmGEE40IAlmQBVmQBVmQBVmQBVmQBXk/g5YhRCFStvf3mxMvp3x5vZzP+WrKH6+vjFddXu4u56fX0+3T2+Pjzemfu8e3/R/9fLl72ufr3WW8d9zJzk/fxhzg94fHc9b7ze/t7f9Xx4/Ta3n8ZPyxbof225H9PKBzX+O6/VqP7PdY++Nnmev2RQ7sl3z4mft67f6R66/5yLbv66H/XyU+9suV+0c+/+Npin336/bbkY+/KtdvfNs6su+cn3HHP7IfH/vRr9vvR75+TDh/JlfuFz2yr439eu3+ketnzs3X/MjXjzXOr4VcuX/k4/eP+7dvV+6LHdlXrp8fun//uX/o43c+/970yv0j9y/vXL+2bVfuH7n/tcL1a6Vct6965f7f1+/zeOvu/uHy12+c3lO6PNx9fTyvN7+/Pd3/8d7Xf194D7+xerk835+/vV3OKf3+tVU++H2y8e3TdPucr+Pnm+Nubuqf3/O//w8=", + "debug_symbols": "rdnNTlxHEEDhd5k1i9vd9dPNq0SWhfHYQkKAxhApsnj3dN2ug+1FNneySR1C6gtgFzMMP09fz1/evn9+ePr2/ON0+9fP05fLw+Pjw/fPj8/3d68Pz0/z3/48bfGPWk635eZU6xptDVlD17A1/HRb5+hrjH20bY2yxlTaHFOROWQNXcPW8DWmonNMxW5Osq1R1qhrTMXnmEqfQ9ewNXyNqYw5plK2m5NuOUvOmrPllJya03J6zp4zPUvP0rPw5lfCWk7JqTktp+fsOceavuUsOdPz9Dw9T8/T8/Q8PU+vp9fT6+n19Hp6Pb2eXk+vp9fTG+mN9EZ6I72R3khvpDfSG+mN9Mq2EYWoRCOEUMIIJzqBXJALckEuyAW5IBfkglyQC3INuUYUohKNECLkFmGEEyFLxMiIW1kRskZUohEhW4QSRjjRiZDniZS4nxWFqEQjhFDCCCc6gazIiqzIiqzIiqzIiqzIimzIhmzIhmzIhmzIhmzIhuzIjuzIjuzIjuzIjuzIjtyRO3JH7sgduSN35I7ckTvyQB7IA3kg7+fXI5QwwolOhDy/N9b9BvcoRCUaIYQSRjjRCeSCXJALckEuyAW5IBfkglyQK3JFrsgVuSJX5IpckStyRW7IDbkhN+SG3JAbckNuyA1ZkAVZkAVZkAVZkAVZkAVZkRVZkRVZkRVZkRU5brBuESMjbnBFISox5bo/+AuhhBFOdGJkxA2uKEQlkB05brDGc4q4wRVOhNwiRkbc4IpCVCJkiRBCCSOc6MTIiBtcUYiQNaIRQihhRMgW0YmxosUNrihEyB7RCCGUMCLkHtGJkRE3uCLkEVGJRgihxJTbFuFEJ0ZG3OCKQlSiEUIogVyRK3JFbsgNuSE35IbckBtyQ27IDVmQBVmQBVmQBVmQBVmQBVmRFVmRFVmRFVmRFVmRFdmQDdmQDdmQDdmQDdmQDdmR4wZbiahEI4RQIuR4Lh83uKITIyNucEUhKtEIIZRA7sgduSMP5IE8kAfyQB7IA3kgD+SRsmwbUYhKNEIIJYxwohPIBbkgF+SCXJALckEuyAW5IFfkilyRK3JFrsgVuSJX5IrckPcbbBGVaIQQSoQsEU50ImSNH9c2ohCVaITk1n6DeyALsiDvNxg/D+43uEchKtEIIZQwwolOIBuyIRuyIRuyIRuyIRuyITuyIzuyIzuyIzuyIzuyI3fkjtyRO3JH7sgduSN35I48kAfyQB7IA3kgD+SBPJBHyrptRCEq0QghlDDCiZA9YmTsN7hHIULuEY0QQgkjnOjEyNhvcI9CIFfkirzf4IgwwolOjIz9BvcoRCUaIQRyQ27IDbkhC7IgC7IgC7IgC7IgC7IgK7IiK7IiK7IiK7IiK7IiG7IhG7IhG7IhG7IhG7IhO7IjO7IjO7IjO7IjO3LcoOyvF21EIWrE+/vNiZfaPr9ezud4pe23197mK3Ivd5fz0+vp9unt8fHm9Pfd49v+H/14uXva5+vdZb53kuenr3NO8NvD4znq/ebX9vbfq/OFlVyer5F8rOuh/X5kPx5e1n4b1+2LHtkfI/fnT7XX7Zd6YL/G8/y1367dP/L1b/FDyb4/n1Vfue9H9sv42O/X7Ysc2J9P3XJ/Pgs7st/4/OcTmCP7+rFv5cr9I/cznwWw36/cH0fuZz425/58vL1uvx75+unH94/5IHpkX5x9bdft23Zk3z8+/37o83f53/aP3L9tPfft0P3ZVj/25cr9I3//rfHnZ9Ku3D/y/c+M+zPfrty3I/uDj98PPX7+tl+OfPwu/P139ev27cifn/vHx+/juv1u1+2PP+/303zr7v7h8sdvc99DujzcfXk855vf3p7uf3vv6z8vvIffBr9cnu/PX98u55B+/Uo4fpb6S7vcaB+f4ldj8eZoNzr003v87/8F", "file_map": { "50": { - "source": "fn main(x: u64, y: u8, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176, superseded by issue #8791\n assert(u >> (x as u8) == -1);\n assert(z >> (x as u8) == -1);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n\n assert(z >> 16 == -1);\n assert(-z >> x as u8 == 0);\n}\n", + "source": "fn main(x: u64, y: u64, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176, superseded by issue #8791\n assert(u >> (x as i64 - 2) == -1);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> a == 32);\n a = -a;\n assert(a << 6 == -64);\n assert(a << -a == -2);\n\n assert(x >> (x - 1) == 0);\n\n assert_eq(z >> 3, -97);\n\n assert(z >> 14 == -1);\n let rhs = (if x as i16 > 14 { 14 } else { x as i16 });\n assert(z >> rhs == -1);\n assert(-z >> rhs == 0);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__expanded.snap index aa565090cd1..20adc320421 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__expanded.snap @@ -62,16 +62,16 @@ impl U256 { ( ( ( - (((bytes[0_u32] as u64) << 56_u8) + ((bytes[1_u32] as u64) << 48_u8)) - + ((bytes[2_u32] as u64) << 40_u8) + (((bytes[0_u32] as u64) << 56_u64) + ((bytes[1_u32] as u64) << 48_u64)) + + ((bytes[2_u32] as u64) << 40_u64) ) - + ((bytes[3_u32] as u64) << 32_u8) + + ((bytes[3_u32] as u64) << 32_u64) ) - + ((bytes[4_u32] as u64) << 24_u8) + + ((bytes[4_u32] as u64) << 24_u64) ) - + ((bytes[5_u32] as u64) << 16_u8) + + ((bytes[5_u32] as u64) << 16_u64) ) - + ((bytes[6_u32] as u64) << 8_u8) + + ((bytes[6_u32] as u64) << 8_u64) ) + (bytes[7_u32] as u64); let high_1: u64 = ( @@ -79,16 +79,16 @@ impl U256 { ( ( ( - (((bytes[8_u32] as u64) << 56_u8) + ((bytes[9_u32] as u64) << 48_u8)) - + ((bytes[10_u32] as u64) << 40_u8) + (((bytes[8_u32] as u64) << 56_u64) + ((bytes[9_u32] as u64) << 48_u64)) + + ((bytes[10_u32] as u64) << 40_u64) ) - + ((bytes[11_u32] as u64) << 32_u8) + + ((bytes[11_u32] as u64) << 32_u64) ) - + ((bytes[12_u32] as u64) << 24_u8) + + ((bytes[12_u32] as u64) << 24_u64) ) - + ((bytes[13_u32] as u64) << 16_u8) + + ((bytes[13_u32] as u64) << 16_u64) ) - + ((bytes[14_u32] as u64) << 8_u8) + + ((bytes[14_u32] as u64) << 8_u64) ) + (bytes[15_u32] as u64); let low_0: u64 = ( @@ -96,16 +96,19 @@ impl U256 { ( ( ( - (((bytes[16_u32] as u64) << 56_u8) + ((bytes[17_u32] as u64) << 48_u8)) - + ((bytes[18_u32] as u64) << 40_u8) + ( + ((bytes[16_u32] as u64) << 56_u64) + + ((bytes[17_u32] as u64) << 48_u64) + ) + + ((bytes[18_u32] as u64) << 40_u64) ) - + ((bytes[19_u32] as u64) << 32_u8) + + ((bytes[19_u32] as u64) << 32_u64) ) - + ((bytes[20_u32] as u64) << 24_u8) + + ((bytes[20_u32] as u64) << 24_u64) ) - + ((bytes[21_u32] as u64) << 16_u8) + + ((bytes[21_u32] as u64) << 16_u64) ) - + ((bytes[22_u32] as u64) << 8_u8) + + ((bytes[22_u32] as u64) << 8_u64) ) + (bytes[23_u32] as u64); let low_1: u64 = ( @@ -113,16 +116,19 @@ impl U256 { ( ( ( - (((bytes[24_u32] as u64) << 56_u8) + ((bytes[25_u32] as u64) << 48_u8)) - + ((bytes[26_u32] as u64) << 40_u8) + ( + ((bytes[24_u32] as u64) << 56_u64) + + ((bytes[25_u32] as u64) << 48_u64) + ) + + ((bytes[26_u32] as u64) << 40_u64) ) - + ((bytes[27_u32] as u64) << 32_u8) + + ((bytes[27_u32] as u64) << 32_u64) ) - + ((bytes[28_u32] as u64) << 24_u8) + + ((bytes[28_u32] as u64) << 24_u64) ) - + ((bytes[29_u32] as u64) << 16_u8) + + ((bytes[29_u32] as u64) << 16_u64) ) - + ((bytes[30_u32] as u64) << 8_u8) + + ((bytes[30_u32] as u64) << 8_u64) ) + (bytes[31_u32] as u64); Self { inner: [high_0, high_1, low_0, low_1] } diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index e8cf522baa4..9814d75518e 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -165,7 +165,7 @@ expression: artifact "return value indices : [_184, _185]", "BRILLIG CALL func 0: inputs: [[EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ], EXPR [ (1, _2) 0 ], EXPR [ (1, _3) 0 ], EXPR [ (1, _4) 0 ], EXPR [ (1, _5) 0 ], EXPR [ (1, _6) 0 ], EXPR [ (1, _7) 0 ], EXPR [ (1, _8) 0 ], EXPR [ (1, _9) 0 ], EXPR [ (1, _10) 0 ], EXPR [ (1, _11) 0 ], EXPR [ (1, _12) 0 ], EXPR [ (1, _13) 0 ], EXPR [ (1, _14) 0 ], EXPR [ (1, _15) 0 ], EXPR [ (1, _16) 0 ], EXPR [ (1, _17) 0 ], EXPR [ (1, _18) 0 ], EXPR [ (1, _19) 0 ], EXPR [ (1, _20) 0 ], EXPR [ (1, _21) 0 ], EXPR [ (1, _22) 0 ], EXPR [ (1, _23) 0 ], EXPR [ (1, _24) 0 ], EXPR [ (1, _25) 0 ], EXPR [ (1, _26) 0 ], EXPR [ (1, _27) 0 ], EXPR [ (1, _28) 0 ], EXPR [ (1, _29) 0 ], EXPR [ (1, _30) 0 ], EXPR [ (1, _31) 0 ], EXPR [ (1, _32) 0 ], EXPR [ (1, _33) 0 ], EXPR [ (1, _34) 0 ], EXPR [ (1, _35) 0 ], EXPR [ (1, _36) 0 ], EXPR [ (1, _37) 0 ], EXPR [ (1, _38) 0 ], EXPR [ (1, _39) 0 ], EXPR [ (1, _40) 0 ], EXPR [ (1, _41) 0 ], EXPR [ (1, _42) 0 ], EXPR [ (1, _43) 0 ], EXPR [ (1, _44) 0 ], EXPR [ (1, _45) 0 ], EXPR [ (1, _46) 0 ], EXPR [ (1, _47) 0 ], EXPR [ (1, _48) 0 ], EXPR [ (1, _49) 0 ], EXPR [ (1, _50) 0 ], EXPR [ (1, _51) 0 ], EXPR [ (1, _52) 0 ], EXPR [ (1, _53) 0 ], EXPR [ (1, _54) 0 ], EXPR [ (1, _55) 0 ], EXPR [ (1, _56) 0 ], EXPR [ (1, _57) 0 ], EXPR [ (1, _58) 0 ], EXPR [ (1, _59) 0 ], EXPR [ (1, _60) 0 ], EXPR [ (1, _61) 0 ], EXPR [ (1, _62) 0 ], EXPR [ (1, _63) 0 ]], [EXPR [ (1, _64) 0 ], EXPR [ (1, _65) 0 ], EXPR [ (1, _66) 0 ], EXPR [ (1, _67) 0 ], EXPR [ (1, _68) 0 ], EXPR [ (1, _69) 0 ], EXPR [ (1, _70) 0 ], EXPR [ (1, _71) 0 ], EXPR [ (1, _72) 0 ], EXPR [ (1, _73) 0 ], EXPR [ (1, _74) 0 ], EXPR [ (1, _75) 0 ], EXPR [ (1, _76) 0 ], EXPR [ (1, _77) 0 ], EXPR [ (1, _78) 0 ], EXPR [ (1, _79) 0 ], EXPR [ (1, _80) 0 ], EXPR [ (1, _81) 0 ], EXPR [ (1, _82) 0 ], EXPR [ (1, _83) 0 ], EXPR [ (1, _84) 0 ], EXPR [ (1, _85) 0 ], EXPR [ (1, _86) 0 ], EXPR [ (1, _87) 0 ], EXPR [ (1, _88) 0 ], EXPR [ (1, _89) 0 ], EXPR [ (1, _90) 0 ], EXPR [ (1, _91) 0 ], EXPR [ (1, _92) 0 ], EXPR [ (1, _93) 0 ], EXPR [ (1, _94) 0 ], EXPR [ (1, _95) 0 ], EXPR [ (1, _96) 0 ], EXPR [ (1, _97) 0 ], EXPR [ (1, _98) 0 ], EXPR [ (1, _99) 0 ], EXPR [ (1, _100) 0 ], EXPR [ (1, _101) 0 ], EXPR [ (1, _102) 0 ], EXPR [ (1, _103) 0 ], EXPR [ (1, _104) 0 ], EXPR [ (1, _105) 0 ], EXPR [ (1, _106) 0 ], EXPR [ (1, _107) 0 ], EXPR [ (1, _108) 0 ], EXPR [ (1, _109) 0 ], EXPR [ (1, _110) 0 ], EXPR [ (1, _111) 0 ], EXPR [ (1, _112) 0 ], EXPR [ (1, _113) 0 ], EXPR [ (1, _114) 0 ], EXPR [ (1, _115) 0 ], EXPR [ (1, _116) 0 ], EXPR [ (1, _117) 0 ], EXPR [ (1, _118) 0 ], EXPR [ (1, _119) 0 ], EXPR [ (1, _120) 0 ], EXPR [ (1, _121) 0 ], EXPR [ (1, _122) 0 ], EXPR [ (1, _123) 0 ], EXPR [ (1, _124) 0 ], EXPR [ (1, _125) 0 ], EXPR [ (1, _126) 0 ], EXPR [ (1, _127) 0 ]], [EXPR [ (1, _128) 0 ], EXPR [ (1, _129) 0 ], EXPR [ (1, _130) 0 ], EXPR [ (1, _131) 0 ], EXPR [ (1, _132) 0 ], EXPR [ (1, _133) 0 ], EXPR [ (1, _134) 0 ], EXPR [ (1, _135) 0 ], EXPR [ (1, _136) 0 ], EXPR [ (1, _137) 0 ], EXPR [ (1, _138) 0 ], EXPR [ (1, _139) 0 ], EXPR [ (1, _140) 0 ], EXPR [ (1, _141) 0 ], EXPR [ (1, _142) 0 ], EXPR [ (1, _143) 0 ], EXPR [ (1, _144) 0 ], EXPR [ (1, _145) 0 ], EXPR [ (1, _146) 0 ], EXPR [ (1, _147) 0 ], EXPR [ (1, _148) 0 ], EXPR [ (1, _149) 0 ], EXPR [ (1, _150) 0 ], EXPR [ (1, _151) 0 ], EXPR [ (1, _152) 0 ], EXPR [ (1, _153) 0 ], EXPR [ (1, _154) 0 ], EXPR [ (1, _155) 0 ], EXPR [ (1, _156) 0 ], EXPR [ (1, _157) 0 ], EXPR [ (1, _158) 0 ], EXPR [ (1, _159) 0 ], EXPR [ (1, _160) 0 ], EXPR [ (1, _161) 0 ], EXPR [ (1, _162) 0 ], EXPR [ (1, _163) 0 ], EXPR [ (1, _164) 0 ], EXPR [ (1, _165) 0 ], EXPR [ (1, _166) 0 ], EXPR [ (1, _167) 0 ], EXPR [ (1, _168) 0 ], EXPR [ (1, _169) 0 ], EXPR [ (1, _170) 0 ], EXPR [ (1, _171) 0 ], EXPR [ (1, _172) 0 ], EXPR [ (1, _173) 0 ], EXPR [ (1, _174) 0 ], EXPR [ (1, _175) 0 ]], [EXPR [ (1, _176) 0 ], EXPR [ (1, _177) 0 ]], [EXPR [ (1, _178) 0 ], EXPR [ (1, _179) 0 ]], [EXPR [ (1, _180) 0 ], EXPR [ (1, _181) 0 ]], [EXPR [ (1, _182) 0 ], EXPR [ (1, _183) 0 ]]], outputs: [[_184, _185]]", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 33038 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 184 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32852), size_address: Relative(8), offset_address: Relative(9) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32852 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(1), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32916 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(2), source: Relative(8) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32980 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 48 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 49 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(3), source: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 33028 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(4), source: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33030 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(5), source: Relative(8) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33032 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(6), source: Relative(8) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33034 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(7), source: Relative(8) }, Call { location: 113 }, Call { location: 131 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 33036 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 2 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 102 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 33036 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 112 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 105 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 64 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 16 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 169 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 165 }, Const { destination: Direct(32841), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32842), bit_size: Field, value: 340282366920938463463374607431768211456 }, Const { destination: Direct(32843), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32844), bit_size: Field, value: 2 }, Const { destination: Direct(32845), bit_size: Integer(U32), value: 3 }, Const { destination: Direct(32846), bit_size: Integer(U32), value: 5 }, Const { destination: Direct(32847), bit_size: Integer(U32), value: 6 }, Const { destination: Direct(32848), bit_size: Integer(U32), value: 7 }, Const { destination: Direct(32849), bit_size: Integer(U32), value: 8 }, Const { destination: Direct(32850), bit_size: Integer(U32), value: 9 }, Const { destination: Direct(32851), bit_size: Integer(U32), value: 32 }, Return, Call { location: 823 }, Const { destination: Relative(9), bit_size: Field, value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 170 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 169 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Mov { destination: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 147 }, Store { destination_pointer: Relative(13), source: Relative(9) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Jump { location: 141 }, Mov { destination: Relative(11), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 156 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(2) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 164 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(3) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 172 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 180 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(5) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 188 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(6) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(10) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 196 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(10), source: Relative(18) }, Mov { destination: Relative(8), source: Relative(18) }, Jump { location: 204 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, JumpIf { condition: Relative(12), location: 800 }, Jump { location: 207 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 212 }, Call { location: 832 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 215 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(8), location: 777 }, Jump { location: 218 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(12), location: 223 }, Call { location: 832 }, Store { destination_pointer: Relative(10), source: Relative(8) }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 226 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 734 }, Jump { location: 229 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(8), location: 234 }, Call { location: 832 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(12), location: 240 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(3) }, Store { destination_pointer: Relative(14), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 251 }, Call { location: 832 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 256 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(2) }, Store { destination_pointer: Relative(14), source: Relative(8) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 267 }, Call { location: 832 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(12) }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(8) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(14), source: Relative(13) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(13), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(14) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Direct(32843) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Direct(32843) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Direct(32843) }, Mov { destination: Relative(14), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Const { destination: Relative(12), bit_size: Field, value: 3728882899078719075161482178784387565366481897740339799480980287259621149274 }, Const { destination: Relative(15), bit_size: Field, value: -9903063709032878667290627648209915537972247634463802596148419711785767431332 }, Const { destination: Relative(16), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(17), bit_size: Field, value: 2393473289045184898987089634332637236754766663897650125720167164137088869378 }, Const { destination: Relative(19), bit_size: Field, value: -7135402912423807765050323395026152633898511180575289670895350565966806597339 }, Mov { destination: Relative(20), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Mov { destination: Relative(22), source: Relative(21) }, Store { destination_pointer: Relative(22), source: Relative(12) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(15) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(16) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(17) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(16) }, Const { destination: Relative(12), bit_size: Field, value: 8680525429001239497728366687280168587232520577698044359798894838135247199343 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 351 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, JumpIf { condition: Relative(15), location: 664 }, Jump { location: 354 }, Load { destination: Relative(7), source_pointer: Relative(13) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32846) }, Store { destination_pointer: Relative(15), source: Direct(32844) }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 838 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32847) }, Store { destination_pointer: Relative(15), source: Relative(9) }, Store { destination_pointer: Relative(13), source: Relative(7) }, Load { destination: Relative(9), source_pointer: Relative(14) }, Const { destination: Relative(12), bit_size: Field, value: -1094708040843609169356775910874053498301840173462935739639689208799068762676 }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32848) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Const { destination: Relative(9), bit_size: Field, value: -718703907181967287621274717949248537252263842169639534402461291799004475262 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32849) }, Store { destination_pointer: Relative(15), source: Relative(9) }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(9), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32850) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BlackBox(MultiScalarMul { points: HeapVector { pointer: Relative(13), size: Relative(14) }, scalars: HeapVector { pointer: Relative(15), size: Relative(16) }, outputs: HeapArray { pointer: Relative(17), size: 3 } }), BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(9), location: 405 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(9), source: Direct(32773) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(2) }, Store { destination_pointer: Relative(13), source: Relative(7) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 416 }, Call { location: 832 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(2), location: 419 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(2), source: Direct(32773) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(12), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 430 }, Call { location: 832 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 433 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(3) }, Store { destination_pointer: Relative(12), source: Relative(8) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 444 }, Call { location: 832 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 449 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 460 }, Call { location: 832 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Load { destination: Relative(7), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 465 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(5), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 476 }, Call { location: 832 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 481 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 492 }, Call { location: 832 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 497 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(6), source: Direct(32773) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(11), source: Relative(6) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 509 }, Call { location: 832 }, Store { destination_pointer: Relative(10), source: Relative(2) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(3), location: 514 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Relative(2), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5345 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(4) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Mov { destination: Relative(6), source: Relative(4) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 529 }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Jump { location: 523 }, Mov { destination: Relative(2), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5344 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 536 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32840) }, JumpIf { condition: Relative(5), location: 621 }, Jump { location: 539 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5280 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 542 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(6), location: 570 }, Jump { location: 545 }, Load { destination: Relative(1), source_pointer: Relative(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake2s { message: HeapVector { pointer: Relative(3), size: Relative(4) }, output: HeapArray { pointer: Relative(5), size: 32 } }), Const { destination: Relative(3), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(4), source: Direct(0) }, Mov { destination: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 860 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(4), source: Direct(0) }, Mov { destination: Relative(5), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1139 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(5) }, Mov { destination: Relative(1), source: Relative(2) }, Return, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Direct(32839) }, JumpIf { condition: Relative(9), location: 575 }, Call { location: 835 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(7) }, Load { destination: Relative(9), source_pointer: Relative(12) }, Const { destination: Relative(8), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 16 }, BlackBox(ToRadix { input: Relative(9), radix: Relative(3), output_pointer: Relative(10), num_limbs: Relative(12), output_bits: Relative(8) }), BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, JumpIf { condition: Relative(10), location: 591 }, Call { location: 832 }, Mov { destination: Relative(6), source: Relative(18) }, Jump { location: 593 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 599 }, Jump { location: 596 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 542 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, JumpIf { condition: Relative(10), location: 603 }, Call { location: 832 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(6) }, Load { destination: Relative(10), source_pointer: Relative(13) }, Load { destination: Relative(12), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(13), location: 610 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 838 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Store { destination_pointer: Relative(15), source: Relative(10) }, Store { destination_pointer: Relative(2), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Mov { destination: Relative(6), source: Relative(8) }, Jump { location: 593 }, Load { destination: Relative(6), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Load { destination: Relative(7), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(6), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, BlackBox(ToRadix { input: Relative(7), radix: Relative(3), output_pointer: Relative(9), num_limbs: Relative(10), output_bits: Relative(8) }), BinaryIntOp { destination: Relative(7), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32851) }, Mov { destination: Relative(5), source: Relative(18) }, Jump { location: 636 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Direct(32851) }, JumpIf { condition: Relative(8), location: 642 }, Jump { location: 639 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(5) }, Jump { location: 536 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(5) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Relative(7), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 646 }, Call { location: 832 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(5) }, Load { destination: Relative(9), source_pointer: Relative(12) }, Load { destination: Relative(10), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(12), location: 653 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(10) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Store { destination_pointer: Relative(2), source: Relative(12) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Mov { destination: Relative(5), source: Relative(8) }, Jump { location: 636 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(1) }, Load { destination: Relative(15), source_pointer: Relative(19) }, Cast { destination: Relative(19), source: Relative(15), bit_size: Integer(U128) }, Cast { destination: Relative(17), source: Relative(19), bit_size: Field }, BinaryFieldOp { destination: Relative(19), op: Sub, lhs: Relative(15), rhs: Relative(17) }, BinaryFieldOp { destination: Relative(21), op: Mul, lhs: Relative(19), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(19), op: Mul, lhs: Direct(32842), rhs: Relative(21) }, BinaryFieldOp { destination: Relative(22), op: Add, lhs: Relative(17), rhs: Relative(19) }, BinaryFieldOp { destination: Relative(19), op: Equals, lhs: Relative(15), rhs: Relative(22) }, JumpIf { condition: Relative(19), location: 677 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Load { destination: Relative(15), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(19), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 838 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(19) }, Store { destination_pointer: Relative(24), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 838 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(15) }, Store { destination_pointer: Relative(23), source: Relative(21) }, Store { destination_pointer: Relative(13), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(19) }, Load { destination: Relative(21), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Load { destination: Relative(23), source_pointer: Relative(25) }, Load { destination: Relative(22), source_pointer: Relative(14) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(24), source: Direct(32773) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(15) }, Store { destination_pointer: Relative(26), source: Relative(17) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(21) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(19), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(23) }, Store { destination_pointer: Relative(14), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(15) }, Jump { location: 351 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 740 }, Call { location: 832 }, BinaryIntOp { destination: Relative(2), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(2) }, Load { destination: Relative(8), source_pointer: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 748 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 759 }, Call { location: 832 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Load { destination: Relative(2), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32839) }, JumpIf { condition: Relative(12), location: 766 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, Store { destination_pointer: Relative(15), source: Relative(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 226 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 782 }, Call { location: 832 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 789 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 215 }, Load { destination: Relative(12), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 805 }, Call { location: 832 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 812 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, Store { destination_pointer: Relative(11), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32838) }, Mov { destination: Relative(8), source: Relative(12) }, Jump { location: 204 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 828 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 842 }, Jump { location: 844 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 859 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 856 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 849 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 859 }, Return, Call { location: 823 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Load { destination: Relative(2), source_pointer: Relative(3) }, Cast { destination: Relative(3), source: Relative(2), bit_size: Integer(U64) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 56 }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(3), bit_size: Integer(U64) }, Const { destination: Relative(3), bit_size: Integer(U8), value: 48 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 875 }, Call { location: 832 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, Load { destination: Relative(4), source_pointer: Relative(6) }, Cast { destination: Relative(6), source: Relative(4), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 40 }, BinaryIntOp { destination: Relative(7), op: Shl, bit_size: U64, lhs: Relative(6), rhs: Relative(4) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U64, lhs: Relative(5), rhs: Relative(7) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 884 }, Call { location: 832 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, Load { destination: Relative(5), source_pointer: Relative(7) }, Cast { destination: Relative(7), source: Relative(5), bit_size: Integer(U64) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(8), op: Shl, bit_size: U64, lhs: Relative(7), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U64, lhs: Relative(6), rhs: Relative(7) }, JumpIf { condition: Relative(9), location: 893 }, Call { location: 832 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32846) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Cast { destination: Relative(8), source: Relative(6), bit_size: Integer(U64) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 24 }, BinaryIntOp { destination: Relative(9), op: Shl, bit_size: U64, lhs: Relative(8), rhs: Relative(6) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U64, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U64, lhs: Relative(7), rhs: Relative(8) }, JumpIf { condition: Relative(10), location: 902 }, Call { location: 832 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, Load { destination: Relative(7), source_pointer: Relative(9) }, Cast { destination: Relative(9), source: Relative(7), bit_size: Integer(U64) }, Const { destination: Relative(7), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(10), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(7) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U64, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 911 }, Call { location: 832 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Cast { destination: Relative(10), source: Relative(8), bit_size: Integer(U64) }, Const { destination: Relative(8), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(8) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(10) }, JumpIf { condition: Relative(12), location: 920 }, Call { location: 832 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32849) }, Load { destination: Relative(9), source_pointer: Relative(11) }, Cast { destination: Relative(11), source: Relative(9), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(9) }, JumpIf { condition: Relative(12), location: 927 }, Call { location: 832 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32850) }, Load { destination: Relative(10), source_pointer: Relative(11) }, Cast { destination: Relative(11), source: Relative(10), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(10), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(2) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(11), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(3) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 940 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(4) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 949 }, Call { location: 832 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(11), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(5) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 958 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 967 }, Call { location: 832 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 14 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(11), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(7) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 976 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 15 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(8) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 985 }, Call { location: 832 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Load { destination: Relative(11), source_pointer: Relative(12) }, Cast { destination: Relative(12), source: Relative(11), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 992 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 18 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 1006 }, Call { location: 832 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 19 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(12), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(12), rhs: Relative(4) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1015 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 1024 }, Call { location: 832 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 21 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(12), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(12), rhs: Relative(6) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1033 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 22 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 1042 }, Call { location: 832 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 23 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(12), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(12), rhs: Relative(8) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1051 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 24 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1059 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 25 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 26 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Load { destination: Relative(10), source_pointer: Relative(14) }, Cast { destination: Relative(2), source: Relative(10), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(10), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 1073 }, Call { location: 832 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Load { destination: Relative(10), source_pointer: Relative(12) }, Cast { destination: Relative(3), source: Relative(10), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(10), op: Shl, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(10) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 1082 }, Call { location: 832 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(10) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(5) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1091 }, Call { location: 832 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(3), rhs: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 1100 }, Call { location: 832 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1109 }, Call { location: 832 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(3), rhs: Relative(8) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 1118 }, Call { location: 832 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32851) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Cast { destination: Relative(1), source: Relative(2), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(3), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 1125 }, Call { location: 832 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(9) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(13) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Return, Call { location: 823 }, Const { destination: Relative(2), bit_size: Field, value: 64 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Direct(32844) }, Mov { destination: Relative(7), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 1175 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Cast { destination: Relative(4), source: Relative(2), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Mul, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(4), op: Add, lhs: Relative(2), rhs: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(2), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Mul, lhs: Relative(5), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Cast { destination: Relative(1), source: Relative(3), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(2), rhs: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(2) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(4) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Return, Call { location: 823 }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(5), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(4), source: Relative(5) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(8), bit_size: Integer(U1), value: 1 }, Mov { destination: Relative(6), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, BlackBox(ToRadix { input: Relative(2), radix: Relative(7), output_pointer: Relative(9), num_limbs: Relative(10), output_bits: Relative(8) }), Const { destination: Relative(11), bit_size: Integer(U32), value: 32 }, Mov { destination: Direct(32771), source: Relative(9) }, Mov { destination: Direct(32772), source: Relative(11) }, Call { location: 1223 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 33 }, Mov { destination: Relative(3), source: Direct(32838) }, Jump { location: 1196 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 1201 }, Jump { location: 1199 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(7), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(7), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Sub, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(9), location: 1207 }, Call { location: 1242 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Direct(32851) }, JumpIf { condition: Relative(9), location: 1210 }, Call { location: 835 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(7) }, Load { destination: Relative(9), source_pointer: Relative(11) }, Cast { destination: Relative(7), source: Relative(9), bit_size: Field }, BinaryFieldOp { destination: Relative(9), op: Mul, lhs: Relative(8), rhs: Relative(1) }, BinaryFieldOp { destination: Relative(10), op: Mul, lhs: Relative(7), rhs: Relative(9) }, BinaryFieldOp { destination: Relative(9), op: Sub, lhs: Relative(5), rhs: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(9), rhs: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Add, lhs: Relative(10), rhs: Relative(7) }, Store { destination_pointer: Relative(4), source: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Mov { destination: Relative(3), source: Relative(7) }, Jump { location: 1196 }, Const { destination: Direct(32774), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32773), op: Div, bit_size: U32, lhs: Direct(32772), rhs: Direct(32774) }, Mov { destination: Direct(32776), source: Direct(32772) }, Const { destination: Direct(32777), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Direct(32778), op: LessThan, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, Not { destination: Direct(32778), source: Direct(32778), bit_size: U1 }, JumpIf { condition: Direct(32778), location: 1241 }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32777) }, Load { destination: Direct(32774), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32777) }, Store { destination_pointer: Direct(32779), source: Direct(32775) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Store { destination_pointer: Direct(32779), source: Direct(32774) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 1227 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 33038 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 184 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32852), size_address: Relative(8), offset_address: Relative(9) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32852 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(1), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32916 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(2), source: Relative(8) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32980 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 48 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 49 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(3), source: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 33028 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(4), source: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33030 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(5), source: Relative(8) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33032 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(6), source: Relative(8) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33034 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(7), source: Relative(8) }, Call { location: 113 }, Call { location: 131 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 33036 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 2 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 102 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 33036 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 112 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 105 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 64 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 16 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 169 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 165 }, Const { destination: Direct(32841), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32842), bit_size: Field, value: 340282366920938463463374607431768211456 }, Const { destination: Direct(32843), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32844), bit_size: Field, value: 2 }, Const { destination: Direct(32845), bit_size: Integer(U32), value: 3 }, Const { destination: Direct(32846), bit_size: Integer(U32), value: 5 }, Const { destination: Direct(32847), bit_size: Integer(U32), value: 6 }, Const { destination: Direct(32848), bit_size: Integer(U32), value: 7 }, Const { destination: Direct(32849), bit_size: Integer(U32), value: 8 }, Const { destination: Direct(32850), bit_size: Integer(U32), value: 9 }, Const { destination: Direct(32851), bit_size: Integer(U32), value: 32 }, Return, Call { location: 823 }, Const { destination: Relative(9), bit_size: Field, value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 170 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 169 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Mov { destination: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 147 }, Store { destination_pointer: Relative(13), source: Relative(9) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Jump { location: 141 }, Mov { destination: Relative(11), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 156 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(2) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 164 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(3) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 172 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 180 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(5) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 188 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(6) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(10) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 196 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(10), source: Relative(18) }, Mov { destination: Relative(8), source: Relative(18) }, Jump { location: 204 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, JumpIf { condition: Relative(12), location: 800 }, Jump { location: 207 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 212 }, Call { location: 832 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 215 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(8), location: 777 }, Jump { location: 218 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(12), location: 223 }, Call { location: 832 }, Store { destination_pointer: Relative(10), source: Relative(8) }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 226 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 734 }, Jump { location: 229 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(8), location: 234 }, Call { location: 832 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(12), location: 240 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(3) }, Store { destination_pointer: Relative(14), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 251 }, Call { location: 832 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 256 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(2) }, Store { destination_pointer: Relative(14), source: Relative(8) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 267 }, Call { location: 832 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(12) }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(8) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(14), source: Relative(13) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(13), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(14) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Direct(32843) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Direct(32843) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Direct(32843) }, Mov { destination: Relative(14), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Const { destination: Relative(12), bit_size: Field, value: 3728882899078719075161482178784387565366481897740339799480980287259621149274 }, Const { destination: Relative(15), bit_size: Field, value: -9903063709032878667290627648209915537972247634463802596148419711785767431332 }, Const { destination: Relative(16), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(17), bit_size: Field, value: 2393473289045184898987089634332637236754766663897650125720167164137088869378 }, Const { destination: Relative(19), bit_size: Field, value: -7135402912423807765050323395026152633898511180575289670895350565966806597339 }, Mov { destination: Relative(20), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Mov { destination: Relative(22), source: Relative(21) }, Store { destination_pointer: Relative(22), source: Relative(12) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(15) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(16) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(17) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(16) }, Const { destination: Relative(12), bit_size: Field, value: 8680525429001239497728366687280168587232520577698044359798894838135247199343 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 351 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, JumpIf { condition: Relative(15), location: 664 }, Jump { location: 354 }, Load { destination: Relative(7), source_pointer: Relative(13) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32846) }, Store { destination_pointer: Relative(15), source: Direct(32844) }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 838 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32847) }, Store { destination_pointer: Relative(15), source: Relative(9) }, Store { destination_pointer: Relative(13), source: Relative(7) }, Load { destination: Relative(9), source_pointer: Relative(14) }, Const { destination: Relative(12), bit_size: Field, value: -1094708040843609169356775910874053498301840173462935739639689208799068762676 }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32848) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Const { destination: Relative(9), bit_size: Field, value: -718703907181967287621274717949248537252263842169639534402461291799004475262 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32849) }, Store { destination_pointer: Relative(15), source: Relative(9) }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(9), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32850) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BlackBox(MultiScalarMul { points: HeapVector { pointer: Relative(13), size: Relative(14) }, scalars: HeapVector { pointer: Relative(15), size: Relative(16) }, outputs: HeapArray { pointer: Relative(17), size: 3 } }), BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(9), location: 405 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(9), source: Direct(32773) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(2) }, Store { destination_pointer: Relative(13), source: Relative(7) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 416 }, Call { location: 832 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(2), location: 419 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(2), source: Direct(32773) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(12), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 430 }, Call { location: 832 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 433 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(3) }, Store { destination_pointer: Relative(12), source: Relative(8) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 444 }, Call { location: 832 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 449 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 460 }, Call { location: 832 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Load { destination: Relative(7), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 465 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(5), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 476 }, Call { location: 832 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 481 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 492 }, Call { location: 832 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 497 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(6), source: Direct(32773) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(11), source: Relative(6) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 509 }, Call { location: 832 }, Store { destination_pointer: Relative(10), source: Relative(2) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(3), location: 514 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Relative(2), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5345 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(4) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Mov { destination: Relative(6), source: Relative(4) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 529 }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Jump { location: 523 }, Mov { destination: Relative(2), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5344 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 536 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32840) }, JumpIf { condition: Relative(5), location: 621 }, Jump { location: 539 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5280 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 542 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(6), location: 570 }, Jump { location: 545 }, Load { destination: Relative(1), source_pointer: Relative(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake2s { message: HeapVector { pointer: Relative(3), size: Relative(4) }, output: HeapArray { pointer: Relative(5), size: 32 } }), Const { destination: Relative(3), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(4), source: Direct(0) }, Mov { destination: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 860 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(4), source: Direct(0) }, Mov { destination: Relative(5), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1139 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(5) }, Mov { destination: Relative(1), source: Relative(2) }, Return, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Direct(32839) }, JumpIf { condition: Relative(9), location: 575 }, Call { location: 835 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(7) }, Load { destination: Relative(9), source_pointer: Relative(12) }, Const { destination: Relative(8), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 16 }, BlackBox(ToRadix { input: Relative(9), radix: Relative(3), output_pointer: Relative(10), num_limbs: Relative(12), output_bits: Relative(8) }), BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, JumpIf { condition: Relative(10), location: 591 }, Call { location: 832 }, Mov { destination: Relative(6), source: Relative(18) }, Jump { location: 593 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 599 }, Jump { location: 596 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 542 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, JumpIf { condition: Relative(10), location: 603 }, Call { location: 832 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(6) }, Load { destination: Relative(10), source_pointer: Relative(13) }, Load { destination: Relative(12), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(13), location: 610 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 838 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Store { destination_pointer: Relative(15), source: Relative(10) }, Store { destination_pointer: Relative(2), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Mov { destination: Relative(6), source: Relative(8) }, Jump { location: 593 }, Load { destination: Relative(6), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Load { destination: Relative(7), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(6), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, BlackBox(ToRadix { input: Relative(7), radix: Relative(3), output_pointer: Relative(9), num_limbs: Relative(10), output_bits: Relative(8) }), BinaryIntOp { destination: Relative(7), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32851) }, Mov { destination: Relative(5), source: Relative(18) }, Jump { location: 636 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Direct(32851) }, JumpIf { condition: Relative(8), location: 642 }, Jump { location: 639 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(5) }, Jump { location: 536 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(5) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Relative(7), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 646 }, Call { location: 832 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(5) }, Load { destination: Relative(9), source_pointer: Relative(12) }, Load { destination: Relative(10), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(12), location: 653 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(10) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Store { destination_pointer: Relative(2), source: Relative(12) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Mov { destination: Relative(5), source: Relative(8) }, Jump { location: 636 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(1) }, Load { destination: Relative(15), source_pointer: Relative(19) }, Cast { destination: Relative(19), source: Relative(15), bit_size: Integer(U128) }, Cast { destination: Relative(17), source: Relative(19), bit_size: Field }, BinaryFieldOp { destination: Relative(19), op: Sub, lhs: Relative(15), rhs: Relative(17) }, BinaryFieldOp { destination: Relative(21), op: Mul, lhs: Relative(19), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(19), op: Mul, lhs: Direct(32842), rhs: Relative(21) }, BinaryFieldOp { destination: Relative(22), op: Add, lhs: Relative(17), rhs: Relative(19) }, BinaryFieldOp { destination: Relative(19), op: Equals, lhs: Relative(15), rhs: Relative(22) }, JumpIf { condition: Relative(19), location: 677 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Load { destination: Relative(15), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(19), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 838 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(19) }, Store { destination_pointer: Relative(24), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 838 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(15) }, Store { destination_pointer: Relative(23), source: Relative(21) }, Store { destination_pointer: Relative(13), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(19) }, Load { destination: Relative(21), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Load { destination: Relative(23), source_pointer: Relative(25) }, Load { destination: Relative(22), source_pointer: Relative(14) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(24), source: Direct(32773) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(15) }, Store { destination_pointer: Relative(26), source: Relative(17) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(21) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(19), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(23) }, Store { destination_pointer: Relative(14), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(15) }, Jump { location: 351 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 740 }, Call { location: 832 }, BinaryIntOp { destination: Relative(2), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(2) }, Load { destination: Relative(8), source_pointer: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 748 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 759 }, Call { location: 832 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Load { destination: Relative(2), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32839) }, JumpIf { condition: Relative(12), location: 766 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, Store { destination_pointer: Relative(15), source: Relative(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 226 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 782 }, Call { location: 832 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 789 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 215 }, Load { destination: Relative(12), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 805 }, Call { location: 832 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 812 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, Store { destination_pointer: Relative(11), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32838) }, Mov { destination: Relative(8), source: Relative(12) }, Jump { location: 204 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 828 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 842 }, Jump { location: 844 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 859 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 856 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 849 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 859 }, Return, Call { location: 823 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Load { destination: Relative(2), source_pointer: Relative(3) }, Cast { destination: Relative(3), source: Relative(2), bit_size: Integer(U64) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 56 }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(3), bit_size: Integer(U64) }, Const { destination: Relative(3), bit_size: Integer(U64), value: 48 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 875 }, Call { location: 832 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, Load { destination: Relative(4), source_pointer: Relative(6) }, Cast { destination: Relative(6), source: Relative(4), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 40 }, BinaryIntOp { destination: Relative(7), op: Shl, bit_size: U64, lhs: Relative(6), rhs: Relative(4) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U64, lhs: Relative(5), rhs: Relative(7) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 884 }, Call { location: 832 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, Load { destination: Relative(5), source_pointer: Relative(7) }, Cast { destination: Relative(7), source: Relative(5), bit_size: Integer(U64) }, Const { destination: Relative(5), bit_size: Integer(U64), value: 32 }, BinaryIntOp { destination: Relative(8), op: Shl, bit_size: U64, lhs: Relative(7), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U64, lhs: Relative(6), rhs: Relative(7) }, JumpIf { condition: Relative(9), location: 893 }, Call { location: 832 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32846) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Cast { destination: Relative(8), source: Relative(6), bit_size: Integer(U64) }, Const { destination: Relative(6), bit_size: Integer(U64), value: 24 }, BinaryIntOp { destination: Relative(9), op: Shl, bit_size: U64, lhs: Relative(8), rhs: Relative(6) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U64, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U64, lhs: Relative(7), rhs: Relative(8) }, JumpIf { condition: Relative(10), location: 902 }, Call { location: 832 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, Load { destination: Relative(7), source_pointer: Relative(9) }, Cast { destination: Relative(9), source: Relative(7), bit_size: Integer(U64) }, Const { destination: Relative(7), bit_size: Integer(U64), value: 16 }, BinaryIntOp { destination: Relative(10), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(7) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U64, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 911 }, Call { location: 832 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Cast { destination: Relative(10), source: Relative(8), bit_size: Integer(U64) }, Const { destination: Relative(8), bit_size: Integer(U64), value: 8 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(8) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(10) }, JumpIf { condition: Relative(12), location: 920 }, Call { location: 832 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32849) }, Load { destination: Relative(9), source_pointer: Relative(11) }, Cast { destination: Relative(11), source: Relative(9), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(9) }, JumpIf { condition: Relative(12), location: 927 }, Call { location: 832 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32850) }, Load { destination: Relative(10), source_pointer: Relative(11) }, Cast { destination: Relative(11), source: Relative(10), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(10), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(2) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(11), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(3) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 940 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(4) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 949 }, Call { location: 832 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(11), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(5) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 958 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 967 }, Call { location: 832 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 14 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(11), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(7) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 976 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 15 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(8) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 985 }, Call { location: 832 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Load { destination: Relative(11), source_pointer: Relative(12) }, Cast { destination: Relative(12), source: Relative(11), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 992 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 18 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 1006 }, Call { location: 832 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 19 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(12), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(12), rhs: Relative(4) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1015 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 1024 }, Call { location: 832 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 21 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(12), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(12), rhs: Relative(6) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1033 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 22 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 1042 }, Call { location: 832 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 23 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(12), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(12), rhs: Relative(8) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1051 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 24 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1059 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 25 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 26 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Load { destination: Relative(10), source_pointer: Relative(14) }, Cast { destination: Relative(2), source: Relative(10), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(10), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 1073 }, Call { location: 832 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Load { destination: Relative(10), source_pointer: Relative(12) }, Cast { destination: Relative(3), source: Relative(10), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(10), op: Shl, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(10) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 1082 }, Call { location: 832 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(10) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(5) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1091 }, Call { location: 832 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(3), rhs: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 1100 }, Call { location: 832 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1109 }, Call { location: 832 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(3), rhs: Relative(8) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 1118 }, Call { location: 832 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32851) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Cast { destination: Relative(1), source: Relative(2), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(3), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 1125 }, Call { location: 832 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(9) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(13) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Return, Call { location: 823 }, Const { destination: Relative(2), bit_size: Field, value: 64 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Direct(32844) }, Mov { destination: Relative(7), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 1175 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Cast { destination: Relative(4), source: Relative(2), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Mul, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(4), op: Add, lhs: Relative(2), rhs: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(2), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Mul, lhs: Relative(5), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Cast { destination: Relative(1), source: Relative(3), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(2), rhs: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(2) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(4) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Return, Call { location: 823 }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(5), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(4), source: Relative(5) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(8), bit_size: Integer(U1), value: 1 }, Mov { destination: Relative(6), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, BlackBox(ToRadix { input: Relative(2), radix: Relative(7), output_pointer: Relative(9), num_limbs: Relative(10), output_bits: Relative(8) }), Const { destination: Relative(11), bit_size: Integer(U32), value: 32 }, Mov { destination: Direct(32771), source: Relative(9) }, Mov { destination: Direct(32772), source: Relative(11) }, Call { location: 1223 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 33 }, Mov { destination: Relative(3), source: Direct(32838) }, Jump { location: 1196 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 1201 }, Jump { location: 1199 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(7), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(7), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Sub, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(9), location: 1207 }, Call { location: 1242 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Direct(32851) }, JumpIf { condition: Relative(9), location: 1210 }, Call { location: 835 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(7) }, Load { destination: Relative(9), source_pointer: Relative(11) }, Cast { destination: Relative(7), source: Relative(9), bit_size: Field }, BinaryFieldOp { destination: Relative(9), op: Mul, lhs: Relative(8), rhs: Relative(1) }, BinaryFieldOp { destination: Relative(10), op: Mul, lhs: Relative(7), rhs: Relative(9) }, BinaryFieldOp { destination: Relative(9), op: Sub, lhs: Relative(5), rhs: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(9), rhs: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Add, lhs: Relative(10), rhs: Relative(7) }, Store { destination_pointer: Relative(4), source: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Mov { destination: Relative(3), source: Relative(7) }, Jump { location: 1196 }, Const { destination: Direct(32774), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32773), op: Div, bit_size: U32, lhs: Direct(32772), rhs: Direct(32774) }, Mov { destination: Direct(32776), source: Direct(32772) }, Const { destination: Direct(32777), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Direct(32778), op: LessThan, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, Not { destination: Direct(32778), source: Direct(32778), bit_size: U1 }, JumpIf { condition: Direct(32778), location: 1241 }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32777) }, Load { destination: Direct(32774), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32777) }, Store { destination_pointer: Direct(32779), source: Direct(32775) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Store { destination_pointer: Direct(32779), source: Direct(32774) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 1227 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], "debug_symbols": "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", "file_map": { diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_0.snap index 620bd952ce8..989af314fac 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_0.snap @@ -165,7 +165,7 @@ expression: artifact "return value indices : [_184, _185]", "BRILLIG CALL func 0: inputs: [[EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ], EXPR [ (1, _2) 0 ], EXPR [ (1, _3) 0 ], EXPR [ (1, _4) 0 ], EXPR [ (1, _5) 0 ], EXPR [ (1, _6) 0 ], EXPR [ (1, _7) 0 ], EXPR [ (1, _8) 0 ], EXPR [ (1, _9) 0 ], EXPR [ (1, _10) 0 ], EXPR [ (1, _11) 0 ], EXPR [ (1, _12) 0 ], EXPR [ (1, _13) 0 ], EXPR [ (1, _14) 0 ], EXPR [ (1, _15) 0 ], EXPR [ (1, _16) 0 ], EXPR [ (1, _17) 0 ], EXPR [ (1, _18) 0 ], EXPR [ (1, _19) 0 ], EXPR [ (1, _20) 0 ], EXPR [ (1, _21) 0 ], EXPR [ (1, _22) 0 ], EXPR [ (1, _23) 0 ], EXPR [ (1, _24) 0 ], EXPR [ (1, _25) 0 ], EXPR [ (1, _26) 0 ], EXPR [ (1, _27) 0 ], EXPR [ (1, _28) 0 ], EXPR [ (1, _29) 0 ], EXPR [ (1, _30) 0 ], EXPR [ (1, _31) 0 ], EXPR [ (1, _32) 0 ], EXPR [ (1, _33) 0 ], EXPR [ (1, _34) 0 ], EXPR [ (1, _35) 0 ], EXPR [ (1, _36) 0 ], EXPR [ (1, _37) 0 ], EXPR [ (1, _38) 0 ], EXPR [ (1, _39) 0 ], EXPR [ (1, _40) 0 ], EXPR [ (1, _41) 0 ], EXPR [ (1, _42) 0 ], EXPR [ (1, _43) 0 ], EXPR [ (1, _44) 0 ], EXPR [ (1, _45) 0 ], EXPR [ (1, _46) 0 ], EXPR [ (1, _47) 0 ], EXPR [ (1, _48) 0 ], EXPR [ (1, _49) 0 ], EXPR [ (1, _50) 0 ], EXPR [ (1, _51) 0 ], EXPR [ (1, _52) 0 ], EXPR [ (1, _53) 0 ], EXPR [ (1, _54) 0 ], EXPR [ (1, _55) 0 ], EXPR [ (1, _56) 0 ], EXPR [ (1, _57) 0 ], EXPR [ (1, _58) 0 ], EXPR [ (1, _59) 0 ], EXPR [ (1, _60) 0 ], EXPR [ (1, _61) 0 ], EXPR [ (1, _62) 0 ], EXPR [ (1, _63) 0 ]], [EXPR [ (1, _64) 0 ], EXPR [ (1, _65) 0 ], EXPR [ (1, _66) 0 ], EXPR [ (1, _67) 0 ], EXPR [ (1, _68) 0 ], EXPR [ (1, _69) 0 ], EXPR [ (1, _70) 0 ], EXPR [ (1, _71) 0 ], EXPR [ (1, _72) 0 ], EXPR [ (1, _73) 0 ], EXPR [ (1, _74) 0 ], EXPR [ (1, _75) 0 ], EXPR [ (1, _76) 0 ], EXPR [ (1, _77) 0 ], EXPR [ (1, _78) 0 ], EXPR [ (1, _79) 0 ], EXPR [ (1, _80) 0 ], EXPR [ (1, _81) 0 ], EXPR [ (1, _82) 0 ], EXPR [ (1, _83) 0 ], EXPR [ (1, _84) 0 ], EXPR [ (1, _85) 0 ], EXPR [ (1, _86) 0 ], EXPR [ (1, _87) 0 ], EXPR [ (1, _88) 0 ], EXPR [ (1, _89) 0 ], EXPR [ (1, _90) 0 ], EXPR [ (1, _91) 0 ], EXPR [ (1, _92) 0 ], EXPR [ (1, _93) 0 ], EXPR [ (1, _94) 0 ], EXPR [ (1, _95) 0 ], EXPR [ (1, _96) 0 ], EXPR [ (1, _97) 0 ], EXPR [ (1, _98) 0 ], EXPR [ (1, _99) 0 ], EXPR [ (1, _100) 0 ], EXPR [ (1, _101) 0 ], EXPR [ (1, _102) 0 ], EXPR [ (1, _103) 0 ], EXPR [ (1, _104) 0 ], EXPR [ (1, _105) 0 ], EXPR [ (1, _106) 0 ], EXPR [ (1, _107) 0 ], EXPR [ (1, _108) 0 ], EXPR [ (1, _109) 0 ], EXPR [ (1, _110) 0 ], EXPR [ (1, _111) 0 ], EXPR [ (1, _112) 0 ], EXPR [ (1, _113) 0 ], EXPR [ (1, _114) 0 ], EXPR [ (1, _115) 0 ], EXPR [ (1, _116) 0 ], EXPR [ (1, _117) 0 ], EXPR [ (1, _118) 0 ], EXPR [ (1, _119) 0 ], EXPR [ (1, _120) 0 ], EXPR [ (1, _121) 0 ], EXPR [ (1, _122) 0 ], EXPR [ (1, _123) 0 ], EXPR [ (1, _124) 0 ], EXPR [ (1, _125) 0 ], EXPR [ (1, _126) 0 ], EXPR [ (1, _127) 0 ]], [EXPR [ (1, _128) 0 ], EXPR [ (1, _129) 0 ], EXPR [ (1, _130) 0 ], EXPR [ (1, _131) 0 ], EXPR [ (1, _132) 0 ], EXPR [ (1, _133) 0 ], EXPR [ (1, _134) 0 ], EXPR [ (1, _135) 0 ], EXPR [ (1, _136) 0 ], EXPR [ (1, _137) 0 ], EXPR [ (1, _138) 0 ], EXPR [ (1, _139) 0 ], EXPR [ (1, _140) 0 ], EXPR [ (1, _141) 0 ], EXPR [ (1, _142) 0 ], EXPR [ (1, _143) 0 ], EXPR [ (1, _144) 0 ], EXPR [ (1, _145) 0 ], EXPR [ (1, _146) 0 ], EXPR [ (1, _147) 0 ], EXPR [ (1, _148) 0 ], EXPR [ (1, _149) 0 ], EXPR [ (1, _150) 0 ], EXPR [ (1, _151) 0 ], EXPR [ (1, _152) 0 ], EXPR [ (1, _153) 0 ], EXPR [ (1, _154) 0 ], EXPR [ (1, _155) 0 ], EXPR [ (1, _156) 0 ], EXPR [ (1, _157) 0 ], EXPR [ (1, _158) 0 ], EXPR [ (1, _159) 0 ], EXPR [ (1, _160) 0 ], EXPR [ (1, _161) 0 ], EXPR [ (1, _162) 0 ], EXPR [ (1, _163) 0 ], EXPR [ (1, _164) 0 ], EXPR [ (1, _165) 0 ], EXPR [ (1, _166) 0 ], EXPR [ (1, _167) 0 ], EXPR [ (1, _168) 0 ], EXPR [ (1, _169) 0 ], EXPR [ (1, _170) 0 ], EXPR [ (1, _171) 0 ], EXPR [ (1, _172) 0 ], EXPR [ (1, _173) 0 ], EXPR [ (1, _174) 0 ], EXPR [ (1, _175) 0 ]], [EXPR [ (1, _176) 0 ], EXPR [ (1, _177) 0 ]], [EXPR [ (1, _178) 0 ], EXPR [ (1, _179) 0 ]], [EXPR [ (1, _180) 0 ], EXPR [ (1, _181) 0 ]], [EXPR [ (1, _182) 0 ], EXPR [ (1, _183) 0 ]]], outputs: [[_184, _185]]", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 33029 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 184 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32843), size_address: Relative(8), offset_address: Relative(9) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32843 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(1), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32907 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(2), source: Relative(8) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32971 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 48 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 49 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(3), source: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 33019 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(4), source: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33021 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(5), source: Relative(8) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33023 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(6), source: Relative(8) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33025 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(7), source: Relative(8) }, Call { location: 113 }, Call { location: 122 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 33027 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 2 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 102 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 33027 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 112 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 105 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 64 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 16 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 169 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 165 }, Const { destination: Direct(32841), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32842), bit_size: Field, value: 340282366920938463463374607431768211456 }, Return, Call { location: 1195 }, Const { destination: Relative(9), bit_size: Field, value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 170 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 169 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Mov { destination: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 138 }, Store { destination_pointer: Relative(13), source: Relative(9) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Jump { location: 132 }, Mov { destination: Relative(11), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 147 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(2) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 155 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(3) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 163 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 171 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(5) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 179 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(6) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(10) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 187 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(10), source: Relative(18) }, Const { destination: Relative(19), bit_size: Integer(U1), value: 1 }, Mov { destination: Relative(8), source: Relative(18) }, Jump { location: 196 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, JumpIf { condition: Relative(12), location: 1172 }, Jump { location: 199 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 204 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 207 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(8), location: 1149 }, Jump { location: 210 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(12), location: 215 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 219 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 1106 }, Jump { location: 222 }, Load { destination: Relative(3), source_pointer: Relative(10) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 228 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 234 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, JumpIf { condition: Relative(13), location: 245 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(13), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 250 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Store { destination_pointer: Relative(16), source: Relative(13) }, Store { destination_pointer: Relative(11), source: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 262 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(12) }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(4) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(14), source: Relative(13) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(13), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(14) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, Mov { destination: Relative(14), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Const { destination: Relative(12), bit_size: Field, value: 3728882899078719075161482178784387565366481897740339799480980287259621149274 }, Const { destination: Relative(15), bit_size: Field, value: -9903063709032878667290627648209915537972247634463802596148419711785767431332 }, Const { destination: Relative(16), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(17), bit_size: Field, value: 2393473289045184898987089634332637236754766663897650125720167164137088869378 }, Const { destination: Relative(20), bit_size: Field, value: -7135402912423807765050323395026152633898511180575289670895350565966806597339 }, Mov { destination: Relative(21), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(21), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(20) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, Const { destination: Relative(12), bit_size: Field, value: 8680525429001239497728366687280168587232520577698044359798894838135247199343 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 347 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, JumpIf { condition: Relative(15), location: 1036 }, Jump { location: 350 }, Load { destination: Relative(7), source_pointer: Relative(13) }, Const { destination: Relative(12), bit_size: Field, value: 2 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 5 }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Store { destination_pointer: Relative(20), source: Relative(12) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(7) }, Store { destination_pointer: Relative(21), source: Relative(9) }, Store { destination_pointer: Relative(13), source: Relative(20) }, Load { destination: Relative(9), source_pointer: Relative(14) }, Const { destination: Relative(13), bit_size: Field, value: -1094708040843609169356775910874053498301840173462935739639689208799068762676 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 7 }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(13) }, Const { destination: Relative(9), bit_size: Field, value: -718703907181967287621274717949248537252263842169639534402461291799004475262 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 8 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(13) }, Store { destination_pointer: Relative(23), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 9 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(9) }, Store { destination_pointer: Relative(23), source: Relative(16) }, Store { destination_pointer: Relative(14), source: Relative(21) }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BlackBox(MultiScalarMul { points: HeapVector { pointer: Relative(22), size: Relative(23) }, scalars: HeapVector { pointer: Relative(24), size: Relative(25) }, outputs: HeapArray { pointer: Relative(26), size: 3 } }), BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Load { destination: Relative(20), source_pointer: Relative(21) }, Load { destination: Relative(14), source_pointer: Relative(11) }, Load { destination: Relative(21), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(21), rhs: Direct(32839) }, JumpIf { condition: Relative(22), location: 409 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(21) }, Store { destination_pointer: Relative(24), source: Relative(20) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(21), rhs: Relative(14) }, JumpIf { condition: Relative(20), location: 420 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32839) }, JumpIf { condition: Relative(20), location: 423 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(14) }, Store { destination_pointer: Relative(23), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(21), location: 434 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(21), location: 437 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(20) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 448 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Load { destination: Relative(4), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 453 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(3) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(20), location: 464 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Load { destination: Relative(20), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 469 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(5), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(20) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(14), location: 480 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 485 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(4) }, Store { destination_pointer: Relative(21), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 496 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 501 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(6), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(3) }, Store { destination_pointer: Relative(21), source: Relative(5) }, Store { destination_pointer: Relative(11), source: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 513 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 518 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5345 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Mov { destination: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(6) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 533 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 527 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5344 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 540 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32840) }, JumpIf { condition: Relative(6), location: 993 }, Jump { location: 543 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5280 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(10), location: 942 }, Jump { location: 549 }, Load { destination: Relative(4), source_pointer: Relative(3) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BlackBox(Blake2s { message: HeapVector { pointer: Relative(5), size: Relative(6) }, output: HeapArray { pointer: Relative(10), size: 32 } }), BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(4), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 56 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(4) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(10) }, Cast { destination: Relative(10), source: Relative(5), bit_size: Integer(U64) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 48 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(6), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 572 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(11) }, Cast { destination: Relative(2), source: Relative(6), bit_size: Integer(U64) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 40 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(2) }, JumpIf { condition: Relative(14), location: 581 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32841) }, Load { destination: Relative(10), source_pointer: Relative(11) }, Cast { destination: Relative(11), source: Relative(10), bit_size: Integer(U64) }, Const { destination: Relative(10), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(14), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(11) }, JumpIf { condition: Relative(18), location: 590 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(2), source_pointer: Relative(14) }, Cast { destination: Relative(14), source: Relative(2), bit_size: Integer(U64) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 24 }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(14), rhs: Relative(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(14) }, JumpIf { condition: Relative(18), location: 599 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(15) }, Cast { destination: Relative(7), source: Relative(11), bit_size: Integer(U64) }, Const { destination: Relative(11), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(7), rhs: Relative(11) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(14), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(14), rhs: Relative(7) }, JumpIf { condition: Relative(18), location: 608 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(17) }, Load { destination: Relative(14), source_pointer: Relative(15) }, Cast { destination: Relative(15), source: Relative(14), bit_size: Integer(U64) }, Const { destination: Relative(14), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(7), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(7), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 617 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(7), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(7), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(7) }, JumpIf { condition: Relative(17), location: 624 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(9), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(4) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(5) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 637 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(6) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 646 }, Call { location: 1204 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 655 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 664 }, Call { location: 1204 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 14 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 673 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 15 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 682 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32836) }, Load { destination: Relative(9), source_pointer: Relative(15) }, Cast { destination: Relative(15), source: Relative(9), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 689 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(4) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 18 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(5) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 703 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 19 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 712 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 721 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 21 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 730 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 22 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(11) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 739 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 23 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 748 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 24 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, JumpIf { condition: Relative(18), location: 756 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 25 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 26 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(18) }, Cast { destination: Relative(4), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 770 }, Call { location: 1204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(5), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(13) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 779 }, Call { location: 1204 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(13) }, Cast { destination: Relative(4), source: Relative(6), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(10) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U64, lhs: Relative(5), rhs: Relative(4) }, JumpIf { condition: Relative(10), location: 788 }, Call { location: 1204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, Load { destination: Relative(6), source_pointer: Relative(10) }, Cast { destination: Relative(5), source: Relative(6), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 797 }, Call { location: 1204 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Cast { destination: Relative(4), source: Relative(5), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 806 }, Call { location: 1204 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Cast { destination: Relative(2), source: Relative(5), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 815 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 822 }, Call { location: 1204 }, Mov { destination: Relative(2), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(2), source: Relative(3) }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(10), source: Relative(6) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(19) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33 }, Mov { destination: Relative(1), source: Direct(32838) }, Jump { location: 898 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, JumpIf { condition: Relative(10), location: 920 }, Jump { location: 901 }, Load { destination: Relative(1), source_pointer: Relative(2) }, Cast { destination: Relative(2), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(2), rhs: Relative(1) }, Cast { destination: Relative(2), source: Relative(9), bit_size: Field }, BinaryFieldOp { destination: Relative(5), op: Add, lhs: Relative(3), rhs: Relative(2) }, Cast { destination: Relative(2), source: Relative(17), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(2), rhs: Relative(1) }, Cast { destination: Relative(1), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Add, lhs: Relative(3), rhs: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Return, Load { destination: Relative(10), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(11), op: Mul, lhs: Relative(10), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Sub, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 926 }, Call { location: 1232 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 929 }, Call { location: 1207 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Field }, BinaryFieldOp { destination: Relative(13), op: Mul, lhs: Relative(11), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(14), op: Mul, lhs: Relative(10), rhs: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Sub, lhs: Relative(3), rhs: Relative(10) }, BinaryFieldOp { destination: Relative(10), op: Mul, lhs: Relative(13), rhs: Relative(11) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(14), rhs: Relative(10) }, Store { destination_pointer: Relative(2), source: Relative(11) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 898 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, Load { destination: Relative(20), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32839) }, JumpIf { condition: Relative(21), location: 947 }, Call { location: 1207 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(14) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Const { destination: Relative(20), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 16 }, BlackBox(ToRadix { input: Relative(21), radix: Relative(4), output_pointer: Relative(22), num_limbs: Relative(23), output_bits: Relative(20) }), BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(20) }, BinaryIntOp { destination: Relative(22), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(21) }, JumpIf { condition: Relative(22), location: 963 }, Call { location: 1204 }, Mov { destination: Relative(10), source: Relative(18) }, Jump { location: 965 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Direct(32836) }, JumpIf { condition: Relative(20), location: 971 }, Jump { location: 968 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(10) }, BinaryIntOp { destination: Relative(22), op: LessThanEquals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 975 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(10) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Load { destination: Relative(23), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 982 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 1210 }, Mov { destination: Relative(24), source: Direct(32773) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(20) }, Store { destination_pointer: Relative(26), source: Relative(22) }, Store { destination_pointer: Relative(3), source: Relative(24) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(32838) }, Mov { destination: Relative(10), source: Relative(20) }, Jump { location: 965 }, Load { destination: Relative(10), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, Load { destination: Relative(14), source_pointer: Relative(21) }, Const { destination: Relative(20), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 32 }, BlackBox(ToRadix { input: Relative(14), radix: Relative(4), output_pointer: Relative(21), num_limbs: Relative(22), output_bits: Relative(20) }), BinaryIntOp { destination: Relative(14), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(6), source: Relative(18) }, Jump { location: 1008 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(20), location: 1014 }, Jump { location: 1011 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 540 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(6) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(20) }, JumpIf { condition: Relative(21), location: 1018 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(6) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Load { destination: Relative(22), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(5) }, JumpIf { condition: Relative(23), location: 1025 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 1210 }, Mov { destination: Relative(23), source: Direct(32773) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(20) }, Store { destination_pointer: Relative(25), source: Relative(21) }, Store { destination_pointer: Relative(3), source: Relative(23) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Mov { destination: Relative(6), source: Relative(20) }, Jump { location: 1008 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(1) }, Load { destination: Relative(15), source_pointer: Relative(20) }, Cast { destination: Relative(20), source: Relative(15), bit_size: Integer(U128) }, Cast { destination: Relative(17), source: Relative(20), bit_size: Field }, BinaryFieldOp { destination: Relative(20), op: Sub, lhs: Relative(15), rhs: Relative(17) }, BinaryFieldOp { destination: Relative(22), op: Mul, lhs: Relative(20), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(20), op: Mul, lhs: Direct(32842), rhs: Relative(22) }, BinaryFieldOp { destination: Relative(23), op: Add, lhs: Relative(17), rhs: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(15), rhs: Relative(23) }, JumpIf { condition: Relative(20), location: 1049 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(15), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(23), source: Direct(32773) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(20) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(15) }, Store { destination_pointer: Relative(24), source: Relative(22) }, Store { destination_pointer: Relative(13), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(23) }, Load { destination: Relative(24), source_pointer: Relative(26) }, Load { destination: Relative(23), source_pointer: Relative(14) }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(25), source: Direct(32773) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(15) }, Store { destination_pointer: Relative(27), source: Relative(17) }, Mov { destination: Direct(32771), source: Relative(25) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(20) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(17) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Store { destination_pointer: Relative(14), source: Relative(20) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(15) }, Jump { location: 347 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1112 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 1120 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1131 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Load { destination: Relative(8), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(13), location: 1138 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 219 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 1154 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 1161 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 207 }, Load { destination: Relative(12), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1177 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 1184 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, Store { destination_pointer: Relative(11), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32838) }, Mov { destination: Relative(8), source: Relative(12) }, Jump { location: 196 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 1200 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 1214 }, Jump { location: 1216 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 1231 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 1228 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 1221 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 1231 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 33029 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 184 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32843), size_address: Relative(8), offset_address: Relative(9) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32843 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(1), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32907 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(2), source: Relative(8) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32971 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 48 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 49 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(3), source: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 33019 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(4), source: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33021 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(5), source: Relative(8) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33023 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(6), source: Relative(8) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33025 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(7), source: Relative(8) }, Call { location: 113 }, Call { location: 122 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 33027 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 2 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 102 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 33027 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 112 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 105 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 64 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 16 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 169 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 165 }, Const { destination: Direct(32841), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32842), bit_size: Field, value: 340282366920938463463374607431768211456 }, Return, Call { location: 1195 }, Const { destination: Relative(9), bit_size: Field, value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 170 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 169 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Mov { destination: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 138 }, Store { destination_pointer: Relative(13), source: Relative(9) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Jump { location: 132 }, Mov { destination: Relative(11), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 147 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(2) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 155 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(3) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 163 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 171 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(5) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 179 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(6) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(10) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 187 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(10), source: Relative(18) }, Const { destination: Relative(19), bit_size: Integer(U1), value: 1 }, Mov { destination: Relative(8), source: Relative(18) }, Jump { location: 196 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, JumpIf { condition: Relative(12), location: 1172 }, Jump { location: 199 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 204 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 207 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(8), location: 1149 }, Jump { location: 210 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(12), location: 215 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 219 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 1106 }, Jump { location: 222 }, Load { destination: Relative(3), source_pointer: Relative(10) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 228 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 234 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, JumpIf { condition: Relative(13), location: 245 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(13), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 250 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Store { destination_pointer: Relative(16), source: Relative(13) }, Store { destination_pointer: Relative(11), source: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 262 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(12) }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(4) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(14), source: Relative(13) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(13), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(14) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, Mov { destination: Relative(14), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Const { destination: Relative(12), bit_size: Field, value: 3728882899078719075161482178784387565366481897740339799480980287259621149274 }, Const { destination: Relative(15), bit_size: Field, value: -9903063709032878667290627648209915537972247634463802596148419711785767431332 }, Const { destination: Relative(16), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(17), bit_size: Field, value: 2393473289045184898987089634332637236754766663897650125720167164137088869378 }, Const { destination: Relative(20), bit_size: Field, value: -7135402912423807765050323395026152633898511180575289670895350565966806597339 }, Mov { destination: Relative(21), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(21), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(20) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, Const { destination: Relative(12), bit_size: Field, value: 8680525429001239497728366687280168587232520577698044359798894838135247199343 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 347 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, JumpIf { condition: Relative(15), location: 1036 }, Jump { location: 350 }, Load { destination: Relative(7), source_pointer: Relative(13) }, Const { destination: Relative(12), bit_size: Field, value: 2 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 5 }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Store { destination_pointer: Relative(20), source: Relative(12) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(7) }, Store { destination_pointer: Relative(21), source: Relative(9) }, Store { destination_pointer: Relative(13), source: Relative(20) }, Load { destination: Relative(9), source_pointer: Relative(14) }, Const { destination: Relative(13), bit_size: Field, value: -1094708040843609169356775910874053498301840173462935739639689208799068762676 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 7 }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(13) }, Const { destination: Relative(9), bit_size: Field, value: -718703907181967287621274717949248537252263842169639534402461291799004475262 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 8 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(13) }, Store { destination_pointer: Relative(23), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 9 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(9) }, Store { destination_pointer: Relative(23), source: Relative(16) }, Store { destination_pointer: Relative(14), source: Relative(21) }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BlackBox(MultiScalarMul { points: HeapVector { pointer: Relative(22), size: Relative(23) }, scalars: HeapVector { pointer: Relative(24), size: Relative(25) }, outputs: HeapArray { pointer: Relative(26), size: 3 } }), BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Load { destination: Relative(20), source_pointer: Relative(21) }, Load { destination: Relative(14), source_pointer: Relative(11) }, Load { destination: Relative(21), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(21), rhs: Direct(32839) }, JumpIf { condition: Relative(22), location: 409 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(21) }, Store { destination_pointer: Relative(24), source: Relative(20) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(21), rhs: Relative(14) }, JumpIf { condition: Relative(20), location: 420 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32839) }, JumpIf { condition: Relative(20), location: 423 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(14) }, Store { destination_pointer: Relative(23), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(21), location: 434 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(21), location: 437 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(20) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 448 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Load { destination: Relative(4), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 453 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(3) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(20), location: 464 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Load { destination: Relative(20), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 469 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(5), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(20) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(14), location: 480 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 485 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(4) }, Store { destination_pointer: Relative(21), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 496 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 501 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(6), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(3) }, Store { destination_pointer: Relative(21), source: Relative(5) }, Store { destination_pointer: Relative(11), source: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 513 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 518 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5345 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Mov { destination: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(6) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 533 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 527 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5344 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 540 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32840) }, JumpIf { condition: Relative(6), location: 993 }, Jump { location: 543 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5280 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(10), location: 942 }, Jump { location: 549 }, Load { destination: Relative(4), source_pointer: Relative(3) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BlackBox(Blake2s { message: HeapVector { pointer: Relative(5), size: Relative(6) }, output: HeapArray { pointer: Relative(10), size: 32 } }), BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(4), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 56 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(4) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(10) }, Cast { destination: Relative(10), source: Relative(5), bit_size: Integer(U64) }, Const { destination: Relative(5), bit_size: Integer(U64), value: 48 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(6), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 572 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(11) }, Cast { destination: Relative(2), source: Relative(6), bit_size: Integer(U64) }, Const { destination: Relative(6), bit_size: Integer(U64), value: 40 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(2) }, JumpIf { condition: Relative(14), location: 581 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32841) }, Load { destination: Relative(10), source_pointer: Relative(11) }, Cast { destination: Relative(11), source: Relative(10), bit_size: Integer(U64) }, Const { destination: Relative(10), bit_size: Integer(U64), value: 32 }, BinaryIntOp { destination: Relative(14), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(11) }, JumpIf { condition: Relative(18), location: 590 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(2), source_pointer: Relative(14) }, Cast { destination: Relative(14), source: Relative(2), bit_size: Integer(U64) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 24 }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(14), rhs: Relative(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(14) }, JumpIf { condition: Relative(18), location: 599 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(15) }, Cast { destination: Relative(7), source: Relative(11), bit_size: Integer(U64) }, Const { destination: Relative(11), bit_size: Integer(U64), value: 16 }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(7), rhs: Relative(11) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(14), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(14), rhs: Relative(7) }, JumpIf { condition: Relative(18), location: 608 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(17) }, Load { destination: Relative(14), source_pointer: Relative(15) }, Cast { destination: Relative(15), source: Relative(14), bit_size: Integer(U64) }, Const { destination: Relative(14), bit_size: Integer(U64), value: 8 }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(7), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(7), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 617 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(7), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(7), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(7) }, JumpIf { condition: Relative(17), location: 624 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(9), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(4) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(5) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 637 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(6) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 646 }, Call { location: 1204 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 655 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 664 }, Call { location: 1204 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 14 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 673 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 15 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 682 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32836) }, Load { destination: Relative(9), source_pointer: Relative(15) }, Cast { destination: Relative(15), source: Relative(9), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 689 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(4) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 18 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(5) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 703 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 19 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 712 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 721 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 21 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 730 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 22 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(11) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 739 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 23 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 748 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 24 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, JumpIf { condition: Relative(18), location: 756 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 25 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 26 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(18) }, Cast { destination: Relative(4), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 770 }, Call { location: 1204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(5), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(13) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 779 }, Call { location: 1204 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(13) }, Cast { destination: Relative(4), source: Relative(6), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(10) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U64, lhs: Relative(5), rhs: Relative(4) }, JumpIf { condition: Relative(10), location: 788 }, Call { location: 1204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, Load { destination: Relative(6), source_pointer: Relative(10) }, Cast { destination: Relative(5), source: Relative(6), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 797 }, Call { location: 1204 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Cast { destination: Relative(4), source: Relative(5), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 806 }, Call { location: 1204 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Cast { destination: Relative(2), source: Relative(5), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 815 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 822 }, Call { location: 1204 }, Mov { destination: Relative(2), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(2), source: Relative(3) }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(10), source: Relative(6) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(19) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33 }, Mov { destination: Relative(1), source: Direct(32838) }, Jump { location: 898 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, JumpIf { condition: Relative(10), location: 920 }, Jump { location: 901 }, Load { destination: Relative(1), source_pointer: Relative(2) }, Cast { destination: Relative(2), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(2), rhs: Relative(1) }, Cast { destination: Relative(2), source: Relative(9), bit_size: Field }, BinaryFieldOp { destination: Relative(5), op: Add, lhs: Relative(3), rhs: Relative(2) }, Cast { destination: Relative(2), source: Relative(17), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(2), rhs: Relative(1) }, Cast { destination: Relative(1), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Add, lhs: Relative(3), rhs: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Return, Load { destination: Relative(10), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(11), op: Mul, lhs: Relative(10), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Sub, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 926 }, Call { location: 1232 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 929 }, Call { location: 1207 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Field }, BinaryFieldOp { destination: Relative(13), op: Mul, lhs: Relative(11), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(14), op: Mul, lhs: Relative(10), rhs: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Sub, lhs: Relative(3), rhs: Relative(10) }, BinaryFieldOp { destination: Relative(10), op: Mul, lhs: Relative(13), rhs: Relative(11) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(14), rhs: Relative(10) }, Store { destination_pointer: Relative(2), source: Relative(11) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 898 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, Load { destination: Relative(20), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32839) }, JumpIf { condition: Relative(21), location: 947 }, Call { location: 1207 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(14) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Const { destination: Relative(20), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 16 }, BlackBox(ToRadix { input: Relative(21), radix: Relative(4), output_pointer: Relative(22), num_limbs: Relative(23), output_bits: Relative(20) }), BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(20) }, BinaryIntOp { destination: Relative(22), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(21) }, JumpIf { condition: Relative(22), location: 963 }, Call { location: 1204 }, Mov { destination: Relative(10), source: Relative(18) }, Jump { location: 965 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Direct(32836) }, JumpIf { condition: Relative(20), location: 971 }, Jump { location: 968 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(10) }, BinaryIntOp { destination: Relative(22), op: LessThanEquals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 975 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(10) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Load { destination: Relative(23), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 982 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 1210 }, Mov { destination: Relative(24), source: Direct(32773) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(20) }, Store { destination_pointer: Relative(26), source: Relative(22) }, Store { destination_pointer: Relative(3), source: Relative(24) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(32838) }, Mov { destination: Relative(10), source: Relative(20) }, Jump { location: 965 }, Load { destination: Relative(10), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, Load { destination: Relative(14), source_pointer: Relative(21) }, Const { destination: Relative(20), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 32 }, BlackBox(ToRadix { input: Relative(14), radix: Relative(4), output_pointer: Relative(21), num_limbs: Relative(22), output_bits: Relative(20) }), BinaryIntOp { destination: Relative(14), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(6), source: Relative(18) }, Jump { location: 1008 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(20), location: 1014 }, Jump { location: 1011 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 540 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(6) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(20) }, JumpIf { condition: Relative(21), location: 1018 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(6) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Load { destination: Relative(22), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(5) }, JumpIf { condition: Relative(23), location: 1025 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 1210 }, Mov { destination: Relative(23), source: Direct(32773) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(20) }, Store { destination_pointer: Relative(25), source: Relative(21) }, Store { destination_pointer: Relative(3), source: Relative(23) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Mov { destination: Relative(6), source: Relative(20) }, Jump { location: 1008 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(1) }, Load { destination: Relative(15), source_pointer: Relative(20) }, Cast { destination: Relative(20), source: Relative(15), bit_size: Integer(U128) }, Cast { destination: Relative(17), source: Relative(20), bit_size: Field }, BinaryFieldOp { destination: Relative(20), op: Sub, lhs: Relative(15), rhs: Relative(17) }, BinaryFieldOp { destination: Relative(22), op: Mul, lhs: Relative(20), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(20), op: Mul, lhs: Direct(32842), rhs: Relative(22) }, BinaryFieldOp { destination: Relative(23), op: Add, lhs: Relative(17), rhs: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(15), rhs: Relative(23) }, JumpIf { condition: Relative(20), location: 1049 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(15), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(23), source: Direct(32773) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(20) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(15) }, Store { destination_pointer: Relative(24), source: Relative(22) }, Store { destination_pointer: Relative(13), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(23) }, Load { destination: Relative(24), source_pointer: Relative(26) }, Load { destination: Relative(23), source_pointer: Relative(14) }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(25), source: Direct(32773) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(15) }, Store { destination_pointer: Relative(27), source: Relative(17) }, Mov { destination: Direct(32771), source: Relative(25) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(20) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(17) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Store { destination_pointer: Relative(14), source: Relative(20) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(15) }, Jump { location: 347 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1112 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 1120 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1131 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Load { destination: Relative(8), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(13), location: 1138 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 219 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 1154 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 1161 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 207 }, Load { destination: Relative(12), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1177 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 1184 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, Store { destination_pointer: Relative(11), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32838) }, Mov { destination: Relative(8), source: Relative(12) }, Jump { location: 196 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 1200 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 1214 }, Jump { location: 1216 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 1231 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 1228 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 1221 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 1231 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], "debug_symbols": "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", "file_map": { diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 620bd952ce8..989af314fac 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -165,7 +165,7 @@ expression: artifact "return value indices : [_184, _185]", "BRILLIG CALL func 0: inputs: [[EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ], EXPR [ (1, _2) 0 ], EXPR [ (1, _3) 0 ], EXPR [ (1, _4) 0 ], EXPR [ (1, _5) 0 ], EXPR [ (1, _6) 0 ], EXPR [ (1, _7) 0 ], EXPR [ (1, _8) 0 ], EXPR [ (1, _9) 0 ], EXPR [ (1, _10) 0 ], EXPR [ (1, _11) 0 ], EXPR [ (1, _12) 0 ], EXPR [ (1, _13) 0 ], EXPR [ (1, _14) 0 ], EXPR [ (1, _15) 0 ], EXPR [ (1, _16) 0 ], EXPR [ (1, _17) 0 ], EXPR [ (1, _18) 0 ], EXPR [ (1, _19) 0 ], EXPR [ (1, _20) 0 ], EXPR [ (1, _21) 0 ], EXPR [ (1, _22) 0 ], EXPR [ (1, _23) 0 ], EXPR [ (1, _24) 0 ], EXPR [ (1, _25) 0 ], EXPR [ (1, _26) 0 ], EXPR [ (1, _27) 0 ], EXPR [ (1, _28) 0 ], EXPR [ (1, _29) 0 ], EXPR [ (1, _30) 0 ], EXPR [ (1, _31) 0 ], EXPR [ (1, _32) 0 ], EXPR [ (1, _33) 0 ], EXPR [ (1, _34) 0 ], EXPR [ (1, _35) 0 ], EXPR [ (1, _36) 0 ], EXPR [ (1, _37) 0 ], EXPR [ (1, _38) 0 ], EXPR [ (1, _39) 0 ], EXPR [ (1, _40) 0 ], EXPR [ (1, _41) 0 ], EXPR [ (1, _42) 0 ], EXPR [ (1, _43) 0 ], EXPR [ (1, _44) 0 ], EXPR [ (1, _45) 0 ], EXPR [ (1, _46) 0 ], EXPR [ (1, _47) 0 ], EXPR [ (1, _48) 0 ], EXPR [ (1, _49) 0 ], EXPR [ (1, _50) 0 ], EXPR [ (1, _51) 0 ], EXPR [ (1, _52) 0 ], EXPR [ (1, _53) 0 ], EXPR [ (1, _54) 0 ], EXPR [ (1, _55) 0 ], EXPR [ (1, _56) 0 ], EXPR [ (1, _57) 0 ], EXPR [ (1, _58) 0 ], EXPR [ (1, _59) 0 ], EXPR [ (1, _60) 0 ], EXPR [ (1, _61) 0 ], EXPR [ (1, _62) 0 ], EXPR [ (1, _63) 0 ]], [EXPR [ (1, _64) 0 ], EXPR [ (1, _65) 0 ], EXPR [ (1, _66) 0 ], EXPR [ (1, _67) 0 ], EXPR [ (1, _68) 0 ], EXPR [ (1, _69) 0 ], EXPR [ (1, _70) 0 ], EXPR [ (1, _71) 0 ], EXPR [ (1, _72) 0 ], EXPR [ (1, _73) 0 ], EXPR [ (1, _74) 0 ], EXPR [ (1, _75) 0 ], EXPR [ (1, _76) 0 ], EXPR [ (1, _77) 0 ], EXPR [ (1, _78) 0 ], EXPR [ (1, _79) 0 ], EXPR [ (1, _80) 0 ], EXPR [ (1, _81) 0 ], EXPR [ (1, _82) 0 ], EXPR [ (1, _83) 0 ], EXPR [ (1, _84) 0 ], EXPR [ (1, _85) 0 ], EXPR [ (1, _86) 0 ], EXPR [ (1, _87) 0 ], EXPR [ (1, _88) 0 ], EXPR [ (1, _89) 0 ], EXPR [ (1, _90) 0 ], EXPR [ (1, _91) 0 ], EXPR [ (1, _92) 0 ], EXPR [ (1, _93) 0 ], EXPR [ (1, _94) 0 ], EXPR [ (1, _95) 0 ], EXPR [ (1, _96) 0 ], EXPR [ (1, _97) 0 ], EXPR [ (1, _98) 0 ], EXPR [ (1, _99) 0 ], EXPR [ (1, _100) 0 ], EXPR [ (1, _101) 0 ], EXPR [ (1, _102) 0 ], EXPR [ (1, _103) 0 ], EXPR [ (1, _104) 0 ], EXPR [ (1, _105) 0 ], EXPR [ (1, _106) 0 ], EXPR [ (1, _107) 0 ], EXPR [ (1, _108) 0 ], EXPR [ (1, _109) 0 ], EXPR [ (1, _110) 0 ], EXPR [ (1, _111) 0 ], EXPR [ (1, _112) 0 ], EXPR [ (1, _113) 0 ], EXPR [ (1, _114) 0 ], EXPR [ (1, _115) 0 ], EXPR [ (1, _116) 0 ], EXPR [ (1, _117) 0 ], EXPR [ (1, _118) 0 ], EXPR [ (1, _119) 0 ], EXPR [ (1, _120) 0 ], EXPR [ (1, _121) 0 ], EXPR [ (1, _122) 0 ], EXPR [ (1, _123) 0 ], EXPR [ (1, _124) 0 ], EXPR [ (1, _125) 0 ], EXPR [ (1, _126) 0 ], EXPR [ (1, _127) 0 ]], [EXPR [ (1, _128) 0 ], EXPR [ (1, _129) 0 ], EXPR [ (1, _130) 0 ], EXPR [ (1, _131) 0 ], EXPR [ (1, _132) 0 ], EXPR [ (1, _133) 0 ], EXPR [ (1, _134) 0 ], EXPR [ (1, _135) 0 ], EXPR [ (1, _136) 0 ], EXPR [ (1, _137) 0 ], EXPR [ (1, _138) 0 ], EXPR [ (1, _139) 0 ], EXPR [ (1, _140) 0 ], EXPR [ (1, _141) 0 ], EXPR [ (1, _142) 0 ], EXPR [ (1, _143) 0 ], EXPR [ (1, _144) 0 ], EXPR [ (1, _145) 0 ], EXPR [ (1, _146) 0 ], EXPR [ (1, _147) 0 ], EXPR [ (1, _148) 0 ], EXPR [ (1, _149) 0 ], EXPR [ (1, _150) 0 ], EXPR [ (1, _151) 0 ], EXPR [ (1, _152) 0 ], EXPR [ (1, _153) 0 ], EXPR [ (1, _154) 0 ], EXPR [ (1, _155) 0 ], EXPR [ (1, _156) 0 ], EXPR [ (1, _157) 0 ], EXPR [ (1, _158) 0 ], EXPR [ (1, _159) 0 ], EXPR [ (1, _160) 0 ], EXPR [ (1, _161) 0 ], EXPR [ (1, _162) 0 ], EXPR [ (1, _163) 0 ], EXPR [ (1, _164) 0 ], EXPR [ (1, _165) 0 ], EXPR [ (1, _166) 0 ], EXPR [ (1, _167) 0 ], EXPR [ (1, _168) 0 ], EXPR [ (1, _169) 0 ], EXPR [ (1, _170) 0 ], EXPR [ (1, _171) 0 ], EXPR [ (1, _172) 0 ], EXPR [ (1, _173) 0 ], EXPR [ (1, _174) 0 ], EXPR [ (1, _175) 0 ]], [EXPR [ (1, _176) 0 ], EXPR [ (1, _177) 0 ]], [EXPR [ (1, _178) 0 ], EXPR [ (1, _179) 0 ]], [EXPR [ (1, _180) 0 ], EXPR [ (1, _181) 0 ]], [EXPR [ (1, _182) 0 ], EXPR [ (1, _183) 0 ]]], outputs: [[_184, _185]]", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 33029 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 184 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32843), size_address: Relative(8), offset_address: Relative(9) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32843 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(1), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32907 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(2), source: Relative(8) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32971 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 48 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 49 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(3), source: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 33019 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(4), source: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33021 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(5), source: Relative(8) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33023 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(6), source: Relative(8) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33025 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(7), source: Relative(8) }, Call { location: 113 }, Call { location: 122 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 33027 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 2 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 102 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 33027 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 112 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 105 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 64 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 16 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 169 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 165 }, Const { destination: Direct(32841), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32842), bit_size: Field, value: 340282366920938463463374607431768211456 }, Return, Call { location: 1195 }, Const { destination: Relative(9), bit_size: Field, value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 170 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 169 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Mov { destination: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 138 }, Store { destination_pointer: Relative(13), source: Relative(9) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Jump { location: 132 }, Mov { destination: Relative(11), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 147 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(2) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 155 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(3) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 163 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 171 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(5) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 179 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(6) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(10) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 187 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(10), source: Relative(18) }, Const { destination: Relative(19), bit_size: Integer(U1), value: 1 }, Mov { destination: Relative(8), source: Relative(18) }, Jump { location: 196 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, JumpIf { condition: Relative(12), location: 1172 }, Jump { location: 199 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 204 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 207 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(8), location: 1149 }, Jump { location: 210 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(12), location: 215 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 219 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 1106 }, Jump { location: 222 }, Load { destination: Relative(3), source_pointer: Relative(10) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 228 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 234 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, JumpIf { condition: Relative(13), location: 245 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(13), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 250 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Store { destination_pointer: Relative(16), source: Relative(13) }, Store { destination_pointer: Relative(11), source: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 262 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(12) }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(4) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(14), source: Relative(13) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(13), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(14) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, Mov { destination: Relative(14), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Const { destination: Relative(12), bit_size: Field, value: 3728882899078719075161482178784387565366481897740339799480980287259621149274 }, Const { destination: Relative(15), bit_size: Field, value: -9903063709032878667290627648209915537972247634463802596148419711785767431332 }, Const { destination: Relative(16), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(17), bit_size: Field, value: 2393473289045184898987089634332637236754766663897650125720167164137088869378 }, Const { destination: Relative(20), bit_size: Field, value: -7135402912423807765050323395026152633898511180575289670895350565966806597339 }, Mov { destination: Relative(21), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(21), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(20) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, Const { destination: Relative(12), bit_size: Field, value: 8680525429001239497728366687280168587232520577698044359798894838135247199343 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 347 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, JumpIf { condition: Relative(15), location: 1036 }, Jump { location: 350 }, Load { destination: Relative(7), source_pointer: Relative(13) }, Const { destination: Relative(12), bit_size: Field, value: 2 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 5 }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Store { destination_pointer: Relative(20), source: Relative(12) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(7) }, Store { destination_pointer: Relative(21), source: Relative(9) }, Store { destination_pointer: Relative(13), source: Relative(20) }, Load { destination: Relative(9), source_pointer: Relative(14) }, Const { destination: Relative(13), bit_size: Field, value: -1094708040843609169356775910874053498301840173462935739639689208799068762676 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 7 }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(13) }, Const { destination: Relative(9), bit_size: Field, value: -718703907181967287621274717949248537252263842169639534402461291799004475262 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 8 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(13) }, Store { destination_pointer: Relative(23), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 9 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(9) }, Store { destination_pointer: Relative(23), source: Relative(16) }, Store { destination_pointer: Relative(14), source: Relative(21) }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BlackBox(MultiScalarMul { points: HeapVector { pointer: Relative(22), size: Relative(23) }, scalars: HeapVector { pointer: Relative(24), size: Relative(25) }, outputs: HeapArray { pointer: Relative(26), size: 3 } }), BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Load { destination: Relative(20), source_pointer: Relative(21) }, Load { destination: Relative(14), source_pointer: Relative(11) }, Load { destination: Relative(21), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(21), rhs: Direct(32839) }, JumpIf { condition: Relative(22), location: 409 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(21) }, Store { destination_pointer: Relative(24), source: Relative(20) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(21), rhs: Relative(14) }, JumpIf { condition: Relative(20), location: 420 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32839) }, JumpIf { condition: Relative(20), location: 423 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(14) }, Store { destination_pointer: Relative(23), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(21), location: 434 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(21), location: 437 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(20) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 448 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Load { destination: Relative(4), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 453 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(3) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(20), location: 464 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Load { destination: Relative(20), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 469 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(5), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(20) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(14), location: 480 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 485 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(4) }, Store { destination_pointer: Relative(21), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 496 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 501 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(6), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(3) }, Store { destination_pointer: Relative(21), source: Relative(5) }, Store { destination_pointer: Relative(11), source: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 513 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 518 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5345 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Mov { destination: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(6) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 533 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 527 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5344 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 540 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32840) }, JumpIf { condition: Relative(6), location: 993 }, Jump { location: 543 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5280 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(10), location: 942 }, Jump { location: 549 }, Load { destination: Relative(4), source_pointer: Relative(3) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BlackBox(Blake2s { message: HeapVector { pointer: Relative(5), size: Relative(6) }, output: HeapArray { pointer: Relative(10), size: 32 } }), BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(4), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 56 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(4) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(10) }, Cast { destination: Relative(10), source: Relative(5), bit_size: Integer(U64) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 48 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(6), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 572 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(11) }, Cast { destination: Relative(2), source: Relative(6), bit_size: Integer(U64) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 40 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(2) }, JumpIf { condition: Relative(14), location: 581 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32841) }, Load { destination: Relative(10), source_pointer: Relative(11) }, Cast { destination: Relative(11), source: Relative(10), bit_size: Integer(U64) }, Const { destination: Relative(10), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(14), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(11) }, JumpIf { condition: Relative(18), location: 590 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(2), source_pointer: Relative(14) }, Cast { destination: Relative(14), source: Relative(2), bit_size: Integer(U64) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 24 }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(14), rhs: Relative(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(14) }, JumpIf { condition: Relative(18), location: 599 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(15) }, Cast { destination: Relative(7), source: Relative(11), bit_size: Integer(U64) }, Const { destination: Relative(11), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(7), rhs: Relative(11) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(14), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(14), rhs: Relative(7) }, JumpIf { condition: Relative(18), location: 608 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(17) }, Load { destination: Relative(14), source_pointer: Relative(15) }, Cast { destination: Relative(15), source: Relative(14), bit_size: Integer(U64) }, Const { destination: Relative(14), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(7), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(7), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 617 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(7), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(7), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(7) }, JumpIf { condition: Relative(17), location: 624 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(9), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(4) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(5) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 637 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(6) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 646 }, Call { location: 1204 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 655 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 664 }, Call { location: 1204 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 14 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 673 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 15 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 682 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32836) }, Load { destination: Relative(9), source_pointer: Relative(15) }, Cast { destination: Relative(15), source: Relative(9), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 689 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(4) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 18 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(5) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 703 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 19 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 712 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 721 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 21 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 730 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 22 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(11) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 739 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 23 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 748 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 24 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, JumpIf { condition: Relative(18), location: 756 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 25 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 26 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(18) }, Cast { destination: Relative(4), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 770 }, Call { location: 1204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(5), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(13) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 779 }, Call { location: 1204 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(13) }, Cast { destination: Relative(4), source: Relative(6), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(10) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U64, lhs: Relative(5), rhs: Relative(4) }, JumpIf { condition: Relative(10), location: 788 }, Call { location: 1204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, Load { destination: Relative(6), source_pointer: Relative(10) }, Cast { destination: Relative(5), source: Relative(6), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 797 }, Call { location: 1204 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Cast { destination: Relative(4), source: Relative(5), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 806 }, Call { location: 1204 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Cast { destination: Relative(2), source: Relative(5), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 815 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 822 }, Call { location: 1204 }, Mov { destination: Relative(2), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(2), source: Relative(3) }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(10), source: Relative(6) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(19) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33 }, Mov { destination: Relative(1), source: Direct(32838) }, Jump { location: 898 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, JumpIf { condition: Relative(10), location: 920 }, Jump { location: 901 }, Load { destination: Relative(1), source_pointer: Relative(2) }, Cast { destination: Relative(2), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(2), rhs: Relative(1) }, Cast { destination: Relative(2), source: Relative(9), bit_size: Field }, BinaryFieldOp { destination: Relative(5), op: Add, lhs: Relative(3), rhs: Relative(2) }, Cast { destination: Relative(2), source: Relative(17), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(2), rhs: Relative(1) }, Cast { destination: Relative(1), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Add, lhs: Relative(3), rhs: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Return, Load { destination: Relative(10), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(11), op: Mul, lhs: Relative(10), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Sub, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 926 }, Call { location: 1232 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 929 }, Call { location: 1207 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Field }, BinaryFieldOp { destination: Relative(13), op: Mul, lhs: Relative(11), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(14), op: Mul, lhs: Relative(10), rhs: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Sub, lhs: Relative(3), rhs: Relative(10) }, BinaryFieldOp { destination: Relative(10), op: Mul, lhs: Relative(13), rhs: Relative(11) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(14), rhs: Relative(10) }, Store { destination_pointer: Relative(2), source: Relative(11) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 898 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, Load { destination: Relative(20), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32839) }, JumpIf { condition: Relative(21), location: 947 }, Call { location: 1207 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(14) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Const { destination: Relative(20), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 16 }, BlackBox(ToRadix { input: Relative(21), radix: Relative(4), output_pointer: Relative(22), num_limbs: Relative(23), output_bits: Relative(20) }), BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(20) }, BinaryIntOp { destination: Relative(22), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(21) }, JumpIf { condition: Relative(22), location: 963 }, Call { location: 1204 }, Mov { destination: Relative(10), source: Relative(18) }, Jump { location: 965 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Direct(32836) }, JumpIf { condition: Relative(20), location: 971 }, Jump { location: 968 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(10) }, BinaryIntOp { destination: Relative(22), op: LessThanEquals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 975 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(10) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Load { destination: Relative(23), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 982 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 1210 }, Mov { destination: Relative(24), source: Direct(32773) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(20) }, Store { destination_pointer: Relative(26), source: Relative(22) }, Store { destination_pointer: Relative(3), source: Relative(24) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(32838) }, Mov { destination: Relative(10), source: Relative(20) }, Jump { location: 965 }, Load { destination: Relative(10), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, Load { destination: Relative(14), source_pointer: Relative(21) }, Const { destination: Relative(20), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 32 }, BlackBox(ToRadix { input: Relative(14), radix: Relative(4), output_pointer: Relative(21), num_limbs: Relative(22), output_bits: Relative(20) }), BinaryIntOp { destination: Relative(14), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(6), source: Relative(18) }, Jump { location: 1008 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(20), location: 1014 }, Jump { location: 1011 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 540 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(6) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(20) }, JumpIf { condition: Relative(21), location: 1018 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(6) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Load { destination: Relative(22), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(5) }, JumpIf { condition: Relative(23), location: 1025 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 1210 }, Mov { destination: Relative(23), source: Direct(32773) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(20) }, Store { destination_pointer: Relative(25), source: Relative(21) }, Store { destination_pointer: Relative(3), source: Relative(23) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Mov { destination: Relative(6), source: Relative(20) }, Jump { location: 1008 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(1) }, Load { destination: Relative(15), source_pointer: Relative(20) }, Cast { destination: Relative(20), source: Relative(15), bit_size: Integer(U128) }, Cast { destination: Relative(17), source: Relative(20), bit_size: Field }, BinaryFieldOp { destination: Relative(20), op: Sub, lhs: Relative(15), rhs: Relative(17) }, BinaryFieldOp { destination: Relative(22), op: Mul, lhs: Relative(20), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(20), op: Mul, lhs: Direct(32842), rhs: Relative(22) }, BinaryFieldOp { destination: Relative(23), op: Add, lhs: Relative(17), rhs: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(15), rhs: Relative(23) }, JumpIf { condition: Relative(20), location: 1049 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(15), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(23), source: Direct(32773) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(20) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(15) }, Store { destination_pointer: Relative(24), source: Relative(22) }, Store { destination_pointer: Relative(13), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(23) }, Load { destination: Relative(24), source_pointer: Relative(26) }, Load { destination: Relative(23), source_pointer: Relative(14) }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(25), source: Direct(32773) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(15) }, Store { destination_pointer: Relative(27), source: Relative(17) }, Mov { destination: Direct(32771), source: Relative(25) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(20) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(17) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Store { destination_pointer: Relative(14), source: Relative(20) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(15) }, Jump { location: 347 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1112 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 1120 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1131 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Load { destination: Relative(8), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(13), location: 1138 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 219 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 1154 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 1161 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 207 }, Load { destination: Relative(12), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1177 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 1184 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, Store { destination_pointer: Relative(11), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32838) }, Mov { destination: Relative(8), source: Relative(12) }, Jump { location: 196 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 1200 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 1214 }, Jump { location: 1216 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 1231 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 1228 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 1221 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 1231 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 33029 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 184 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32843), size_address: Relative(8), offset_address: Relative(9) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32843 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(1), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32907 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(2), source: Relative(8) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32971 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 48 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 49 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(3), source: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 33019 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(4), source: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33021 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(5), source: Relative(8) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33023 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(6), source: Relative(8) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33025 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(7), source: Relative(8) }, Call { location: 113 }, Call { location: 122 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 33027 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 2 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 102 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 33027 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 112 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 105 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 64 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 16 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 169 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 165 }, Const { destination: Direct(32841), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32842), bit_size: Field, value: 340282366920938463463374607431768211456 }, Return, Call { location: 1195 }, Const { destination: Relative(9), bit_size: Field, value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 170 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 169 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Mov { destination: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 138 }, Store { destination_pointer: Relative(13), source: Relative(9) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Jump { location: 132 }, Mov { destination: Relative(11), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 147 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(2) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 155 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(3) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 163 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 171 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(5) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 179 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(6) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(10) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 187 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(10), source: Relative(18) }, Const { destination: Relative(19), bit_size: Integer(U1), value: 1 }, Mov { destination: Relative(8), source: Relative(18) }, Jump { location: 196 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, JumpIf { condition: Relative(12), location: 1172 }, Jump { location: 199 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 204 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 207 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(8), location: 1149 }, Jump { location: 210 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(12), location: 215 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 219 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 1106 }, Jump { location: 222 }, Load { destination: Relative(3), source_pointer: Relative(10) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 228 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 234 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, JumpIf { condition: Relative(13), location: 245 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(13), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 250 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Store { destination_pointer: Relative(16), source: Relative(13) }, Store { destination_pointer: Relative(11), source: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 262 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(12) }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(4) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(14), source: Relative(13) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(13), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(14) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, Mov { destination: Relative(14), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Const { destination: Relative(12), bit_size: Field, value: 3728882899078719075161482178784387565366481897740339799480980287259621149274 }, Const { destination: Relative(15), bit_size: Field, value: -9903063709032878667290627648209915537972247634463802596148419711785767431332 }, Const { destination: Relative(16), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(17), bit_size: Field, value: 2393473289045184898987089634332637236754766663897650125720167164137088869378 }, Const { destination: Relative(20), bit_size: Field, value: -7135402912423807765050323395026152633898511180575289670895350565966806597339 }, Mov { destination: Relative(21), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(21), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(20) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, Const { destination: Relative(12), bit_size: Field, value: 8680525429001239497728366687280168587232520577698044359798894838135247199343 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 347 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, JumpIf { condition: Relative(15), location: 1036 }, Jump { location: 350 }, Load { destination: Relative(7), source_pointer: Relative(13) }, Const { destination: Relative(12), bit_size: Field, value: 2 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 5 }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Store { destination_pointer: Relative(20), source: Relative(12) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(7) }, Store { destination_pointer: Relative(21), source: Relative(9) }, Store { destination_pointer: Relative(13), source: Relative(20) }, Load { destination: Relative(9), source_pointer: Relative(14) }, Const { destination: Relative(13), bit_size: Field, value: -1094708040843609169356775910874053498301840173462935739639689208799068762676 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 7 }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(13) }, Const { destination: Relative(9), bit_size: Field, value: -718703907181967287621274717949248537252263842169639534402461291799004475262 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 8 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(13) }, Store { destination_pointer: Relative(23), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 9 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(9) }, Store { destination_pointer: Relative(23), source: Relative(16) }, Store { destination_pointer: Relative(14), source: Relative(21) }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BlackBox(MultiScalarMul { points: HeapVector { pointer: Relative(22), size: Relative(23) }, scalars: HeapVector { pointer: Relative(24), size: Relative(25) }, outputs: HeapArray { pointer: Relative(26), size: 3 } }), BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Load { destination: Relative(20), source_pointer: Relative(21) }, Load { destination: Relative(14), source_pointer: Relative(11) }, Load { destination: Relative(21), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(21), rhs: Direct(32839) }, JumpIf { condition: Relative(22), location: 409 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(21) }, Store { destination_pointer: Relative(24), source: Relative(20) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(21), rhs: Relative(14) }, JumpIf { condition: Relative(20), location: 420 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32839) }, JumpIf { condition: Relative(20), location: 423 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(14) }, Store { destination_pointer: Relative(23), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(21), location: 434 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(21), location: 437 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(20) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 448 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Load { destination: Relative(4), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 453 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(3) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(20), location: 464 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Load { destination: Relative(20), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 469 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(5), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(20) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(14), location: 480 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 485 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(4) }, Store { destination_pointer: Relative(21), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 496 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 501 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(6), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(3) }, Store { destination_pointer: Relative(21), source: Relative(5) }, Store { destination_pointer: Relative(11), source: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 513 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 518 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5345 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Mov { destination: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(6) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 533 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 527 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5344 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 540 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32840) }, JumpIf { condition: Relative(6), location: 993 }, Jump { location: 543 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5280 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(10), location: 942 }, Jump { location: 549 }, Load { destination: Relative(4), source_pointer: Relative(3) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BlackBox(Blake2s { message: HeapVector { pointer: Relative(5), size: Relative(6) }, output: HeapArray { pointer: Relative(10), size: 32 } }), BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(4), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 56 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(4) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(10) }, Cast { destination: Relative(10), source: Relative(5), bit_size: Integer(U64) }, Const { destination: Relative(5), bit_size: Integer(U64), value: 48 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(6), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 572 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(11) }, Cast { destination: Relative(2), source: Relative(6), bit_size: Integer(U64) }, Const { destination: Relative(6), bit_size: Integer(U64), value: 40 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(2) }, JumpIf { condition: Relative(14), location: 581 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32841) }, Load { destination: Relative(10), source_pointer: Relative(11) }, Cast { destination: Relative(11), source: Relative(10), bit_size: Integer(U64) }, Const { destination: Relative(10), bit_size: Integer(U64), value: 32 }, BinaryIntOp { destination: Relative(14), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(11) }, JumpIf { condition: Relative(18), location: 590 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(2), source_pointer: Relative(14) }, Cast { destination: Relative(14), source: Relative(2), bit_size: Integer(U64) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 24 }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(14), rhs: Relative(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(14) }, JumpIf { condition: Relative(18), location: 599 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(15) }, Cast { destination: Relative(7), source: Relative(11), bit_size: Integer(U64) }, Const { destination: Relative(11), bit_size: Integer(U64), value: 16 }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(7), rhs: Relative(11) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(14), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(14), rhs: Relative(7) }, JumpIf { condition: Relative(18), location: 608 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(17) }, Load { destination: Relative(14), source_pointer: Relative(15) }, Cast { destination: Relative(15), source: Relative(14), bit_size: Integer(U64) }, Const { destination: Relative(14), bit_size: Integer(U64), value: 8 }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(7), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(7), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 617 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(7), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(7), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(7) }, JumpIf { condition: Relative(17), location: 624 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(9), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(4) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(5) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 637 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(6) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 646 }, Call { location: 1204 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 655 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 664 }, Call { location: 1204 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 14 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 673 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 15 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 682 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32836) }, Load { destination: Relative(9), source_pointer: Relative(15) }, Cast { destination: Relative(15), source: Relative(9), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 689 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(4) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 18 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(5) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 703 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 19 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 712 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 721 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 21 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 730 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 22 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(11) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 739 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 23 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 748 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 24 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, JumpIf { condition: Relative(18), location: 756 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 25 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 26 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(18) }, Cast { destination: Relative(4), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 770 }, Call { location: 1204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(5), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(13) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 779 }, Call { location: 1204 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(13) }, Cast { destination: Relative(4), source: Relative(6), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(10) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U64, lhs: Relative(5), rhs: Relative(4) }, JumpIf { condition: Relative(10), location: 788 }, Call { location: 1204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, Load { destination: Relative(6), source_pointer: Relative(10) }, Cast { destination: Relative(5), source: Relative(6), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 797 }, Call { location: 1204 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Cast { destination: Relative(4), source: Relative(5), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 806 }, Call { location: 1204 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Cast { destination: Relative(2), source: Relative(5), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 815 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 822 }, Call { location: 1204 }, Mov { destination: Relative(2), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(2), source: Relative(3) }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(10), source: Relative(6) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(19) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33 }, Mov { destination: Relative(1), source: Direct(32838) }, Jump { location: 898 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, JumpIf { condition: Relative(10), location: 920 }, Jump { location: 901 }, Load { destination: Relative(1), source_pointer: Relative(2) }, Cast { destination: Relative(2), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(2), rhs: Relative(1) }, Cast { destination: Relative(2), source: Relative(9), bit_size: Field }, BinaryFieldOp { destination: Relative(5), op: Add, lhs: Relative(3), rhs: Relative(2) }, Cast { destination: Relative(2), source: Relative(17), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(2), rhs: Relative(1) }, Cast { destination: Relative(1), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Add, lhs: Relative(3), rhs: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Return, Load { destination: Relative(10), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(11), op: Mul, lhs: Relative(10), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Sub, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 926 }, Call { location: 1232 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 929 }, Call { location: 1207 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Field }, BinaryFieldOp { destination: Relative(13), op: Mul, lhs: Relative(11), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(14), op: Mul, lhs: Relative(10), rhs: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Sub, lhs: Relative(3), rhs: Relative(10) }, BinaryFieldOp { destination: Relative(10), op: Mul, lhs: Relative(13), rhs: Relative(11) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(14), rhs: Relative(10) }, Store { destination_pointer: Relative(2), source: Relative(11) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 898 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, Load { destination: Relative(20), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32839) }, JumpIf { condition: Relative(21), location: 947 }, Call { location: 1207 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(14) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Const { destination: Relative(20), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 16 }, BlackBox(ToRadix { input: Relative(21), radix: Relative(4), output_pointer: Relative(22), num_limbs: Relative(23), output_bits: Relative(20) }), BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(20) }, BinaryIntOp { destination: Relative(22), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(21) }, JumpIf { condition: Relative(22), location: 963 }, Call { location: 1204 }, Mov { destination: Relative(10), source: Relative(18) }, Jump { location: 965 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Direct(32836) }, JumpIf { condition: Relative(20), location: 971 }, Jump { location: 968 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(10) }, BinaryIntOp { destination: Relative(22), op: LessThanEquals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 975 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(10) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Load { destination: Relative(23), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 982 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 1210 }, Mov { destination: Relative(24), source: Direct(32773) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(20) }, Store { destination_pointer: Relative(26), source: Relative(22) }, Store { destination_pointer: Relative(3), source: Relative(24) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(32838) }, Mov { destination: Relative(10), source: Relative(20) }, Jump { location: 965 }, Load { destination: Relative(10), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, Load { destination: Relative(14), source_pointer: Relative(21) }, Const { destination: Relative(20), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 32 }, BlackBox(ToRadix { input: Relative(14), radix: Relative(4), output_pointer: Relative(21), num_limbs: Relative(22), output_bits: Relative(20) }), BinaryIntOp { destination: Relative(14), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(6), source: Relative(18) }, Jump { location: 1008 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(20), location: 1014 }, Jump { location: 1011 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 540 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(6) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(20) }, JumpIf { condition: Relative(21), location: 1018 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(6) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Load { destination: Relative(22), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(5) }, JumpIf { condition: Relative(23), location: 1025 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 1210 }, Mov { destination: Relative(23), source: Direct(32773) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(20) }, Store { destination_pointer: Relative(25), source: Relative(21) }, Store { destination_pointer: Relative(3), source: Relative(23) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Mov { destination: Relative(6), source: Relative(20) }, Jump { location: 1008 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(1) }, Load { destination: Relative(15), source_pointer: Relative(20) }, Cast { destination: Relative(20), source: Relative(15), bit_size: Integer(U128) }, Cast { destination: Relative(17), source: Relative(20), bit_size: Field }, BinaryFieldOp { destination: Relative(20), op: Sub, lhs: Relative(15), rhs: Relative(17) }, BinaryFieldOp { destination: Relative(22), op: Mul, lhs: Relative(20), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(20), op: Mul, lhs: Direct(32842), rhs: Relative(22) }, BinaryFieldOp { destination: Relative(23), op: Add, lhs: Relative(17), rhs: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(15), rhs: Relative(23) }, JumpIf { condition: Relative(20), location: 1049 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(15), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(23), source: Direct(32773) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(20) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(15) }, Store { destination_pointer: Relative(24), source: Relative(22) }, Store { destination_pointer: Relative(13), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(23) }, Load { destination: Relative(24), source_pointer: Relative(26) }, Load { destination: Relative(23), source_pointer: Relative(14) }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(25), source: Direct(32773) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(15) }, Store { destination_pointer: Relative(27), source: Relative(17) }, Mov { destination: Direct(32771), source: Relative(25) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(20) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(17) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Store { destination_pointer: Relative(14), source: Relative(20) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(15) }, Jump { location: 347 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1112 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 1120 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1131 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Load { destination: Relative(8), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(13), location: 1138 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 219 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 1154 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 1161 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 207 }, Load { destination: Relative(12), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1177 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 1184 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, Store { destination_pointer: Relative(11), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32838) }, Mov { destination: Relative(8), source: Relative(12) }, Jump { location: 196 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 1200 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 1214 }, Jump { location: 1216 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 1231 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 1228 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 1221 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 1231 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], "debug_symbols": "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", "file_map": { diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index e8cf522baa4..9814d75518e 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -165,7 +165,7 @@ expression: artifact "return value indices : [_184, _185]", "BRILLIG CALL func 0: inputs: [[EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ], EXPR [ (1, _2) 0 ], EXPR [ (1, _3) 0 ], EXPR [ (1, _4) 0 ], EXPR [ (1, _5) 0 ], EXPR [ (1, _6) 0 ], EXPR [ (1, _7) 0 ], EXPR [ (1, _8) 0 ], EXPR [ (1, _9) 0 ], EXPR [ (1, _10) 0 ], EXPR [ (1, _11) 0 ], EXPR [ (1, _12) 0 ], EXPR [ (1, _13) 0 ], EXPR [ (1, _14) 0 ], EXPR [ (1, _15) 0 ], EXPR [ (1, _16) 0 ], EXPR [ (1, _17) 0 ], EXPR [ (1, _18) 0 ], EXPR [ (1, _19) 0 ], EXPR [ (1, _20) 0 ], EXPR [ (1, _21) 0 ], EXPR [ (1, _22) 0 ], EXPR [ (1, _23) 0 ], EXPR [ (1, _24) 0 ], EXPR [ (1, _25) 0 ], EXPR [ (1, _26) 0 ], EXPR [ (1, _27) 0 ], EXPR [ (1, _28) 0 ], EXPR [ (1, _29) 0 ], EXPR [ (1, _30) 0 ], EXPR [ (1, _31) 0 ], EXPR [ (1, _32) 0 ], EXPR [ (1, _33) 0 ], EXPR [ (1, _34) 0 ], EXPR [ (1, _35) 0 ], EXPR [ (1, _36) 0 ], EXPR [ (1, _37) 0 ], EXPR [ (1, _38) 0 ], EXPR [ (1, _39) 0 ], EXPR [ (1, _40) 0 ], EXPR [ (1, _41) 0 ], EXPR [ (1, _42) 0 ], EXPR [ (1, _43) 0 ], EXPR [ (1, _44) 0 ], EXPR [ (1, _45) 0 ], EXPR [ (1, _46) 0 ], EXPR [ (1, _47) 0 ], EXPR [ (1, _48) 0 ], EXPR [ (1, _49) 0 ], EXPR [ (1, _50) 0 ], EXPR [ (1, _51) 0 ], EXPR [ (1, _52) 0 ], EXPR [ (1, _53) 0 ], EXPR [ (1, _54) 0 ], EXPR [ (1, _55) 0 ], EXPR [ (1, _56) 0 ], EXPR [ (1, _57) 0 ], EXPR [ (1, _58) 0 ], EXPR [ (1, _59) 0 ], EXPR [ (1, _60) 0 ], EXPR [ (1, _61) 0 ], EXPR [ (1, _62) 0 ], EXPR [ (1, _63) 0 ]], [EXPR [ (1, _64) 0 ], EXPR [ (1, _65) 0 ], EXPR [ (1, _66) 0 ], EXPR [ (1, _67) 0 ], EXPR [ (1, _68) 0 ], EXPR [ (1, _69) 0 ], EXPR [ (1, _70) 0 ], EXPR [ (1, _71) 0 ], EXPR [ (1, _72) 0 ], EXPR [ (1, _73) 0 ], EXPR [ (1, _74) 0 ], EXPR [ (1, _75) 0 ], EXPR [ (1, _76) 0 ], EXPR [ (1, _77) 0 ], EXPR [ (1, _78) 0 ], EXPR [ (1, _79) 0 ], EXPR [ (1, _80) 0 ], EXPR [ (1, _81) 0 ], EXPR [ (1, _82) 0 ], EXPR [ (1, _83) 0 ], EXPR [ (1, _84) 0 ], EXPR [ (1, _85) 0 ], EXPR [ (1, _86) 0 ], EXPR [ (1, _87) 0 ], EXPR [ (1, _88) 0 ], EXPR [ (1, _89) 0 ], EXPR [ (1, _90) 0 ], EXPR [ (1, _91) 0 ], EXPR [ (1, _92) 0 ], EXPR [ (1, _93) 0 ], EXPR [ (1, _94) 0 ], EXPR [ (1, _95) 0 ], EXPR [ (1, _96) 0 ], EXPR [ (1, _97) 0 ], EXPR [ (1, _98) 0 ], EXPR [ (1, _99) 0 ], EXPR [ (1, _100) 0 ], EXPR [ (1, _101) 0 ], EXPR [ (1, _102) 0 ], EXPR [ (1, _103) 0 ], EXPR [ (1, _104) 0 ], EXPR [ (1, _105) 0 ], EXPR [ (1, _106) 0 ], EXPR [ (1, _107) 0 ], EXPR [ (1, _108) 0 ], EXPR [ (1, _109) 0 ], EXPR [ (1, _110) 0 ], EXPR [ (1, _111) 0 ], EXPR [ (1, _112) 0 ], EXPR [ (1, _113) 0 ], EXPR [ (1, _114) 0 ], EXPR [ (1, _115) 0 ], EXPR [ (1, _116) 0 ], EXPR [ (1, _117) 0 ], EXPR [ (1, _118) 0 ], EXPR [ (1, _119) 0 ], EXPR [ (1, _120) 0 ], EXPR [ (1, _121) 0 ], EXPR [ (1, _122) 0 ], EXPR [ (1, _123) 0 ], EXPR [ (1, _124) 0 ], EXPR [ (1, _125) 0 ], EXPR [ (1, _126) 0 ], EXPR [ (1, _127) 0 ]], [EXPR [ (1, _128) 0 ], EXPR [ (1, _129) 0 ], EXPR [ (1, _130) 0 ], EXPR [ (1, _131) 0 ], EXPR [ (1, _132) 0 ], EXPR [ (1, _133) 0 ], EXPR [ (1, _134) 0 ], EXPR [ (1, _135) 0 ], EXPR [ (1, _136) 0 ], EXPR [ (1, _137) 0 ], EXPR [ (1, _138) 0 ], EXPR [ (1, _139) 0 ], EXPR [ (1, _140) 0 ], EXPR [ (1, _141) 0 ], EXPR [ (1, _142) 0 ], EXPR [ (1, _143) 0 ], EXPR [ (1, _144) 0 ], EXPR [ (1, _145) 0 ], EXPR [ (1, _146) 0 ], EXPR [ (1, _147) 0 ], EXPR [ (1, _148) 0 ], EXPR [ (1, _149) 0 ], EXPR [ (1, _150) 0 ], EXPR [ (1, _151) 0 ], EXPR [ (1, _152) 0 ], EXPR [ (1, _153) 0 ], EXPR [ (1, _154) 0 ], EXPR [ (1, _155) 0 ], EXPR [ (1, _156) 0 ], EXPR [ (1, _157) 0 ], EXPR [ (1, _158) 0 ], EXPR [ (1, _159) 0 ], EXPR [ (1, _160) 0 ], EXPR [ (1, _161) 0 ], EXPR [ (1, _162) 0 ], EXPR [ (1, _163) 0 ], EXPR [ (1, _164) 0 ], EXPR [ (1, _165) 0 ], EXPR [ (1, _166) 0 ], EXPR [ (1, _167) 0 ], EXPR [ (1, _168) 0 ], EXPR [ (1, _169) 0 ], EXPR [ (1, _170) 0 ], EXPR [ (1, _171) 0 ], EXPR [ (1, _172) 0 ], EXPR [ (1, _173) 0 ], EXPR [ (1, _174) 0 ], EXPR [ (1, _175) 0 ]], [EXPR [ (1, _176) 0 ], EXPR [ (1, _177) 0 ]], [EXPR [ (1, _178) 0 ], EXPR [ (1, _179) 0 ]], [EXPR [ (1, _180) 0 ], EXPR [ (1, _181) 0 ]], [EXPR [ (1, _182) 0 ], EXPR [ (1, _183) 0 ]]], outputs: [[_184, _185]]", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 33038 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 184 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32852), size_address: Relative(8), offset_address: Relative(9) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32852 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(1), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32916 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(2), source: Relative(8) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32980 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 48 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 49 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(3), source: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 33028 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(4), source: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33030 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(5), source: Relative(8) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33032 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(6), source: Relative(8) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33034 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(7), source: Relative(8) }, Call { location: 113 }, Call { location: 131 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 33036 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 2 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 102 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 33036 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 112 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 105 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 64 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 16 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 169 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 165 }, Const { destination: Direct(32841), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32842), bit_size: Field, value: 340282366920938463463374607431768211456 }, Const { destination: Direct(32843), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32844), bit_size: Field, value: 2 }, Const { destination: Direct(32845), bit_size: Integer(U32), value: 3 }, Const { destination: Direct(32846), bit_size: Integer(U32), value: 5 }, Const { destination: Direct(32847), bit_size: Integer(U32), value: 6 }, Const { destination: Direct(32848), bit_size: Integer(U32), value: 7 }, Const { destination: Direct(32849), bit_size: Integer(U32), value: 8 }, Const { destination: Direct(32850), bit_size: Integer(U32), value: 9 }, Const { destination: Direct(32851), bit_size: Integer(U32), value: 32 }, Return, Call { location: 823 }, Const { destination: Relative(9), bit_size: Field, value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 170 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 169 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Mov { destination: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 147 }, Store { destination_pointer: Relative(13), source: Relative(9) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Jump { location: 141 }, Mov { destination: Relative(11), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 156 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(2) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 164 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(3) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 172 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 180 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(5) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 188 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(6) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(10) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 196 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(10), source: Relative(18) }, Mov { destination: Relative(8), source: Relative(18) }, Jump { location: 204 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, JumpIf { condition: Relative(12), location: 800 }, Jump { location: 207 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 212 }, Call { location: 832 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 215 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(8), location: 777 }, Jump { location: 218 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(12), location: 223 }, Call { location: 832 }, Store { destination_pointer: Relative(10), source: Relative(8) }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 226 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 734 }, Jump { location: 229 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(8), location: 234 }, Call { location: 832 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(12), location: 240 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(3) }, Store { destination_pointer: Relative(14), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 251 }, Call { location: 832 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 256 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(2) }, Store { destination_pointer: Relative(14), source: Relative(8) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 267 }, Call { location: 832 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(12) }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(8) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(14), source: Relative(13) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(13), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(14) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Direct(32843) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Direct(32843) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Direct(32843) }, Mov { destination: Relative(14), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Const { destination: Relative(12), bit_size: Field, value: 3728882899078719075161482178784387565366481897740339799480980287259621149274 }, Const { destination: Relative(15), bit_size: Field, value: -9903063709032878667290627648209915537972247634463802596148419711785767431332 }, Const { destination: Relative(16), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(17), bit_size: Field, value: 2393473289045184898987089634332637236754766663897650125720167164137088869378 }, Const { destination: Relative(19), bit_size: Field, value: -7135402912423807765050323395026152633898511180575289670895350565966806597339 }, Mov { destination: Relative(20), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Mov { destination: Relative(22), source: Relative(21) }, Store { destination_pointer: Relative(22), source: Relative(12) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(15) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(16) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(17) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(16) }, Const { destination: Relative(12), bit_size: Field, value: 8680525429001239497728366687280168587232520577698044359798894838135247199343 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 351 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, JumpIf { condition: Relative(15), location: 664 }, Jump { location: 354 }, Load { destination: Relative(7), source_pointer: Relative(13) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32846) }, Store { destination_pointer: Relative(15), source: Direct(32844) }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 838 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32847) }, Store { destination_pointer: Relative(15), source: Relative(9) }, Store { destination_pointer: Relative(13), source: Relative(7) }, Load { destination: Relative(9), source_pointer: Relative(14) }, Const { destination: Relative(12), bit_size: Field, value: -1094708040843609169356775910874053498301840173462935739639689208799068762676 }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32848) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Const { destination: Relative(9), bit_size: Field, value: -718703907181967287621274717949248537252263842169639534402461291799004475262 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32849) }, Store { destination_pointer: Relative(15), source: Relative(9) }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(9), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32850) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BlackBox(MultiScalarMul { points: HeapVector { pointer: Relative(13), size: Relative(14) }, scalars: HeapVector { pointer: Relative(15), size: Relative(16) }, outputs: HeapArray { pointer: Relative(17), size: 3 } }), BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(9), location: 405 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(9), source: Direct(32773) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(2) }, Store { destination_pointer: Relative(13), source: Relative(7) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 416 }, Call { location: 832 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(2), location: 419 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(2), source: Direct(32773) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(12), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 430 }, Call { location: 832 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 433 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(3) }, Store { destination_pointer: Relative(12), source: Relative(8) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 444 }, Call { location: 832 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 449 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 460 }, Call { location: 832 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Load { destination: Relative(7), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 465 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(5), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 476 }, Call { location: 832 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 481 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 492 }, Call { location: 832 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 497 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(6), source: Direct(32773) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(11), source: Relative(6) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 509 }, Call { location: 832 }, Store { destination_pointer: Relative(10), source: Relative(2) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(3), location: 514 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Relative(2), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5345 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(4) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Mov { destination: Relative(6), source: Relative(4) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 529 }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Jump { location: 523 }, Mov { destination: Relative(2), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5344 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 536 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32840) }, JumpIf { condition: Relative(5), location: 621 }, Jump { location: 539 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5280 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 542 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(6), location: 570 }, Jump { location: 545 }, Load { destination: Relative(1), source_pointer: Relative(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake2s { message: HeapVector { pointer: Relative(3), size: Relative(4) }, output: HeapArray { pointer: Relative(5), size: 32 } }), Const { destination: Relative(3), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(4), source: Direct(0) }, Mov { destination: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 860 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(4), source: Direct(0) }, Mov { destination: Relative(5), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1139 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(5) }, Mov { destination: Relative(1), source: Relative(2) }, Return, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Direct(32839) }, JumpIf { condition: Relative(9), location: 575 }, Call { location: 835 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(7) }, Load { destination: Relative(9), source_pointer: Relative(12) }, Const { destination: Relative(8), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 16 }, BlackBox(ToRadix { input: Relative(9), radix: Relative(3), output_pointer: Relative(10), num_limbs: Relative(12), output_bits: Relative(8) }), BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, JumpIf { condition: Relative(10), location: 591 }, Call { location: 832 }, Mov { destination: Relative(6), source: Relative(18) }, Jump { location: 593 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 599 }, Jump { location: 596 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 542 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, JumpIf { condition: Relative(10), location: 603 }, Call { location: 832 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(6) }, Load { destination: Relative(10), source_pointer: Relative(13) }, Load { destination: Relative(12), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(13), location: 610 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 838 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Store { destination_pointer: Relative(15), source: Relative(10) }, Store { destination_pointer: Relative(2), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Mov { destination: Relative(6), source: Relative(8) }, Jump { location: 593 }, Load { destination: Relative(6), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Load { destination: Relative(7), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(6), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, BlackBox(ToRadix { input: Relative(7), radix: Relative(3), output_pointer: Relative(9), num_limbs: Relative(10), output_bits: Relative(8) }), BinaryIntOp { destination: Relative(7), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32851) }, Mov { destination: Relative(5), source: Relative(18) }, Jump { location: 636 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Direct(32851) }, JumpIf { condition: Relative(8), location: 642 }, Jump { location: 639 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(5) }, Jump { location: 536 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(5) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Relative(7), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 646 }, Call { location: 832 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(5) }, Load { destination: Relative(9), source_pointer: Relative(12) }, Load { destination: Relative(10), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(12), location: 653 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(10) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Store { destination_pointer: Relative(2), source: Relative(12) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Mov { destination: Relative(5), source: Relative(8) }, Jump { location: 636 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(1) }, Load { destination: Relative(15), source_pointer: Relative(19) }, Cast { destination: Relative(19), source: Relative(15), bit_size: Integer(U128) }, Cast { destination: Relative(17), source: Relative(19), bit_size: Field }, BinaryFieldOp { destination: Relative(19), op: Sub, lhs: Relative(15), rhs: Relative(17) }, BinaryFieldOp { destination: Relative(21), op: Mul, lhs: Relative(19), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(19), op: Mul, lhs: Direct(32842), rhs: Relative(21) }, BinaryFieldOp { destination: Relative(22), op: Add, lhs: Relative(17), rhs: Relative(19) }, BinaryFieldOp { destination: Relative(19), op: Equals, lhs: Relative(15), rhs: Relative(22) }, JumpIf { condition: Relative(19), location: 677 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Load { destination: Relative(15), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(19), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 838 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(19) }, Store { destination_pointer: Relative(24), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 838 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(15) }, Store { destination_pointer: Relative(23), source: Relative(21) }, Store { destination_pointer: Relative(13), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(19) }, Load { destination: Relative(21), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Load { destination: Relative(23), source_pointer: Relative(25) }, Load { destination: Relative(22), source_pointer: Relative(14) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(24), source: Direct(32773) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(15) }, Store { destination_pointer: Relative(26), source: Relative(17) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(21) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(19), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(23) }, Store { destination_pointer: Relative(14), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(15) }, Jump { location: 351 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 740 }, Call { location: 832 }, BinaryIntOp { destination: Relative(2), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(2) }, Load { destination: Relative(8), source_pointer: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 748 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 759 }, Call { location: 832 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Load { destination: Relative(2), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32839) }, JumpIf { condition: Relative(12), location: 766 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, Store { destination_pointer: Relative(15), source: Relative(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 226 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 782 }, Call { location: 832 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 789 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 215 }, Load { destination: Relative(12), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 805 }, Call { location: 832 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 812 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, Store { destination_pointer: Relative(11), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32838) }, Mov { destination: Relative(8), source: Relative(12) }, Jump { location: 204 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 828 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 842 }, Jump { location: 844 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 859 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 856 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 849 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 859 }, Return, Call { location: 823 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Load { destination: Relative(2), source_pointer: Relative(3) }, Cast { destination: Relative(3), source: Relative(2), bit_size: Integer(U64) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 56 }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(3), bit_size: Integer(U64) }, Const { destination: Relative(3), bit_size: Integer(U8), value: 48 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 875 }, Call { location: 832 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, Load { destination: Relative(4), source_pointer: Relative(6) }, Cast { destination: Relative(6), source: Relative(4), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 40 }, BinaryIntOp { destination: Relative(7), op: Shl, bit_size: U64, lhs: Relative(6), rhs: Relative(4) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U64, lhs: Relative(5), rhs: Relative(7) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 884 }, Call { location: 832 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, Load { destination: Relative(5), source_pointer: Relative(7) }, Cast { destination: Relative(7), source: Relative(5), bit_size: Integer(U64) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(8), op: Shl, bit_size: U64, lhs: Relative(7), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U64, lhs: Relative(6), rhs: Relative(7) }, JumpIf { condition: Relative(9), location: 893 }, Call { location: 832 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32846) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Cast { destination: Relative(8), source: Relative(6), bit_size: Integer(U64) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 24 }, BinaryIntOp { destination: Relative(9), op: Shl, bit_size: U64, lhs: Relative(8), rhs: Relative(6) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U64, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U64, lhs: Relative(7), rhs: Relative(8) }, JumpIf { condition: Relative(10), location: 902 }, Call { location: 832 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, Load { destination: Relative(7), source_pointer: Relative(9) }, Cast { destination: Relative(9), source: Relative(7), bit_size: Integer(U64) }, Const { destination: Relative(7), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(10), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(7) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U64, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 911 }, Call { location: 832 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Cast { destination: Relative(10), source: Relative(8), bit_size: Integer(U64) }, Const { destination: Relative(8), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(8) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(10) }, JumpIf { condition: Relative(12), location: 920 }, Call { location: 832 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32849) }, Load { destination: Relative(9), source_pointer: Relative(11) }, Cast { destination: Relative(11), source: Relative(9), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(9) }, JumpIf { condition: Relative(12), location: 927 }, Call { location: 832 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32850) }, Load { destination: Relative(10), source_pointer: Relative(11) }, Cast { destination: Relative(11), source: Relative(10), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(10), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(2) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(11), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(3) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 940 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(4) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 949 }, Call { location: 832 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(11), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(5) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 958 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 967 }, Call { location: 832 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 14 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(11), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(7) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 976 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 15 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(8) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 985 }, Call { location: 832 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Load { destination: Relative(11), source_pointer: Relative(12) }, Cast { destination: Relative(12), source: Relative(11), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 992 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 18 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 1006 }, Call { location: 832 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 19 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(12), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(12), rhs: Relative(4) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1015 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 1024 }, Call { location: 832 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 21 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(12), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(12), rhs: Relative(6) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1033 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 22 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 1042 }, Call { location: 832 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 23 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(12), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(12), rhs: Relative(8) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1051 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 24 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1059 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 25 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 26 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Load { destination: Relative(10), source_pointer: Relative(14) }, Cast { destination: Relative(2), source: Relative(10), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(10), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 1073 }, Call { location: 832 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Load { destination: Relative(10), source_pointer: Relative(12) }, Cast { destination: Relative(3), source: Relative(10), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(10), op: Shl, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(10) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 1082 }, Call { location: 832 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(10) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(5) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1091 }, Call { location: 832 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(3), rhs: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 1100 }, Call { location: 832 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1109 }, Call { location: 832 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(3), rhs: Relative(8) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 1118 }, Call { location: 832 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32851) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Cast { destination: Relative(1), source: Relative(2), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(3), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 1125 }, Call { location: 832 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(9) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(13) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Return, Call { location: 823 }, Const { destination: Relative(2), bit_size: Field, value: 64 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Direct(32844) }, Mov { destination: Relative(7), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 1175 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Cast { destination: Relative(4), source: Relative(2), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Mul, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(4), op: Add, lhs: Relative(2), rhs: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(2), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Mul, lhs: Relative(5), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Cast { destination: Relative(1), source: Relative(3), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(2), rhs: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(2) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(4) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Return, Call { location: 823 }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(5), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(4), source: Relative(5) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(8), bit_size: Integer(U1), value: 1 }, Mov { destination: Relative(6), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, BlackBox(ToRadix { input: Relative(2), radix: Relative(7), output_pointer: Relative(9), num_limbs: Relative(10), output_bits: Relative(8) }), Const { destination: Relative(11), bit_size: Integer(U32), value: 32 }, Mov { destination: Direct(32771), source: Relative(9) }, Mov { destination: Direct(32772), source: Relative(11) }, Call { location: 1223 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 33 }, Mov { destination: Relative(3), source: Direct(32838) }, Jump { location: 1196 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 1201 }, Jump { location: 1199 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(7), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(7), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Sub, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(9), location: 1207 }, Call { location: 1242 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Direct(32851) }, JumpIf { condition: Relative(9), location: 1210 }, Call { location: 835 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(7) }, Load { destination: Relative(9), source_pointer: Relative(11) }, Cast { destination: Relative(7), source: Relative(9), bit_size: Field }, BinaryFieldOp { destination: Relative(9), op: Mul, lhs: Relative(8), rhs: Relative(1) }, BinaryFieldOp { destination: Relative(10), op: Mul, lhs: Relative(7), rhs: Relative(9) }, BinaryFieldOp { destination: Relative(9), op: Sub, lhs: Relative(5), rhs: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(9), rhs: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Add, lhs: Relative(10), rhs: Relative(7) }, Store { destination_pointer: Relative(4), source: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Mov { destination: Relative(3), source: Relative(7) }, Jump { location: 1196 }, Const { destination: Direct(32774), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32773), op: Div, bit_size: U32, lhs: Direct(32772), rhs: Direct(32774) }, Mov { destination: Direct(32776), source: Direct(32772) }, Const { destination: Direct(32777), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Direct(32778), op: LessThan, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, Not { destination: Direct(32778), source: Direct(32778), bit_size: U1 }, JumpIf { condition: Direct(32778), location: 1241 }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32777) }, Load { destination: Direct(32774), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32777) }, Store { destination_pointer: Direct(32779), source: Direct(32775) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Store { destination_pointer: Direct(32779), source: Direct(32774) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 1227 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 33038 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 184 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32852), size_address: Relative(8), offset_address: Relative(9) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32852 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(1), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32916 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(2), source: Relative(8) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32980 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 48 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 49 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(3), source: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 33028 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(4), source: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33030 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(5), source: Relative(8) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33032 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(6), source: Relative(8) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33034 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(7), source: Relative(8) }, Call { location: 113 }, Call { location: 131 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 33036 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 2 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 102 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 33036 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 112 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 105 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 64 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 16 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 169 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 165 }, Const { destination: Direct(32841), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32842), bit_size: Field, value: 340282366920938463463374607431768211456 }, Const { destination: Direct(32843), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32844), bit_size: Field, value: 2 }, Const { destination: Direct(32845), bit_size: Integer(U32), value: 3 }, Const { destination: Direct(32846), bit_size: Integer(U32), value: 5 }, Const { destination: Direct(32847), bit_size: Integer(U32), value: 6 }, Const { destination: Direct(32848), bit_size: Integer(U32), value: 7 }, Const { destination: Direct(32849), bit_size: Integer(U32), value: 8 }, Const { destination: Direct(32850), bit_size: Integer(U32), value: 9 }, Const { destination: Direct(32851), bit_size: Integer(U32), value: 32 }, Return, Call { location: 823 }, Const { destination: Relative(9), bit_size: Field, value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 170 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 169 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Mov { destination: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 147 }, Store { destination_pointer: Relative(13), source: Relative(9) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Jump { location: 141 }, Mov { destination: Relative(11), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 156 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(2) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 164 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(3) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 172 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 180 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(5) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 188 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(6) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(10) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 196 }, Call { location: 829 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(10), source: Relative(18) }, Mov { destination: Relative(8), source: Relative(18) }, Jump { location: 204 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, JumpIf { condition: Relative(12), location: 800 }, Jump { location: 207 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 212 }, Call { location: 832 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 215 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(8), location: 777 }, Jump { location: 218 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(12), location: 223 }, Call { location: 832 }, Store { destination_pointer: Relative(10), source: Relative(8) }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 226 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 734 }, Jump { location: 229 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(8), location: 234 }, Call { location: 832 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(12), location: 240 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(3) }, Store { destination_pointer: Relative(14), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 251 }, Call { location: 832 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 256 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(2) }, Store { destination_pointer: Relative(14), source: Relative(8) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 267 }, Call { location: 832 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(12) }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(8) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(14), source: Relative(13) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(13), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(14) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Direct(32843) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Direct(32843) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Direct(32843) }, Mov { destination: Relative(14), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Const { destination: Relative(12), bit_size: Field, value: 3728882899078719075161482178784387565366481897740339799480980287259621149274 }, Const { destination: Relative(15), bit_size: Field, value: -9903063709032878667290627648209915537972247634463802596148419711785767431332 }, Const { destination: Relative(16), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(17), bit_size: Field, value: 2393473289045184898987089634332637236754766663897650125720167164137088869378 }, Const { destination: Relative(19), bit_size: Field, value: -7135402912423807765050323395026152633898511180575289670895350565966806597339 }, Mov { destination: Relative(20), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Mov { destination: Relative(22), source: Relative(21) }, Store { destination_pointer: Relative(22), source: Relative(12) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(15) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(16) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(17) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(16) }, Const { destination: Relative(12), bit_size: Field, value: 8680525429001239497728366687280168587232520577698044359798894838135247199343 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 351 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, JumpIf { condition: Relative(15), location: 664 }, Jump { location: 354 }, Load { destination: Relative(7), source_pointer: Relative(13) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32846) }, Store { destination_pointer: Relative(15), source: Direct(32844) }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 838 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32847) }, Store { destination_pointer: Relative(15), source: Relative(9) }, Store { destination_pointer: Relative(13), source: Relative(7) }, Load { destination: Relative(9), source_pointer: Relative(14) }, Const { destination: Relative(12), bit_size: Field, value: -1094708040843609169356775910874053498301840173462935739639689208799068762676 }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32848) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Const { destination: Relative(9), bit_size: Field, value: -718703907181967287621274717949248537252263842169639534402461291799004475262 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32849) }, Store { destination_pointer: Relative(15), source: Relative(9) }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(9), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32850) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BlackBox(MultiScalarMul { points: HeapVector { pointer: Relative(13), size: Relative(14) }, scalars: HeapVector { pointer: Relative(15), size: Relative(16) }, outputs: HeapArray { pointer: Relative(17), size: 3 } }), BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(9), location: 405 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(9), source: Direct(32773) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(2) }, Store { destination_pointer: Relative(13), source: Relative(7) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 416 }, Call { location: 832 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(2), location: 419 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(2), source: Direct(32773) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(12), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 430 }, Call { location: 832 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 433 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(3) }, Store { destination_pointer: Relative(12), source: Relative(8) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 444 }, Call { location: 832 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 449 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 460 }, Call { location: 832 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Load { destination: Relative(7), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 465 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(5), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 476 }, Call { location: 832 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 481 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 492 }, Call { location: 832 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 497 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(6), source: Direct(32773) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(11), source: Relative(6) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 509 }, Call { location: 832 }, Store { destination_pointer: Relative(10), source: Relative(2) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(3), location: 514 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Relative(2), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5345 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(4) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Mov { destination: Relative(6), source: Relative(4) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 529 }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Jump { location: 523 }, Mov { destination: Relative(2), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5344 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 536 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32840) }, JumpIf { condition: Relative(5), location: 621 }, Jump { location: 539 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5280 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 542 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(6), location: 570 }, Jump { location: 545 }, Load { destination: Relative(1), source_pointer: Relative(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake2s { message: HeapVector { pointer: Relative(3), size: Relative(4) }, output: HeapArray { pointer: Relative(5), size: 32 } }), Const { destination: Relative(3), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(4), source: Direct(0) }, Mov { destination: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 860 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(4), source: Direct(0) }, Mov { destination: Relative(5), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1139 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(5) }, Mov { destination: Relative(1), source: Relative(2) }, Return, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Direct(32839) }, JumpIf { condition: Relative(9), location: 575 }, Call { location: 835 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(7) }, Load { destination: Relative(9), source_pointer: Relative(12) }, Const { destination: Relative(8), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 16 }, BlackBox(ToRadix { input: Relative(9), radix: Relative(3), output_pointer: Relative(10), num_limbs: Relative(12), output_bits: Relative(8) }), BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, JumpIf { condition: Relative(10), location: 591 }, Call { location: 832 }, Mov { destination: Relative(6), source: Relative(18) }, Jump { location: 593 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 599 }, Jump { location: 596 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 542 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, JumpIf { condition: Relative(10), location: 603 }, Call { location: 832 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(6) }, Load { destination: Relative(10), source_pointer: Relative(13) }, Load { destination: Relative(12), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(13), location: 610 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 838 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Store { destination_pointer: Relative(15), source: Relative(10) }, Store { destination_pointer: Relative(2), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Mov { destination: Relative(6), source: Relative(8) }, Jump { location: 593 }, Load { destination: Relative(6), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Load { destination: Relative(7), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(6), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, BlackBox(ToRadix { input: Relative(7), radix: Relative(3), output_pointer: Relative(9), num_limbs: Relative(10), output_bits: Relative(8) }), BinaryIntOp { destination: Relative(7), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32851) }, Mov { destination: Relative(5), source: Relative(18) }, Jump { location: 636 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Direct(32851) }, JumpIf { condition: Relative(8), location: 642 }, Jump { location: 639 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(5) }, Jump { location: 536 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(5) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Relative(7), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 646 }, Call { location: 832 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(5) }, Load { destination: Relative(9), source_pointer: Relative(12) }, Load { destination: Relative(10), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(12), location: 653 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(10) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Store { destination_pointer: Relative(2), source: Relative(12) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Mov { destination: Relative(5), source: Relative(8) }, Jump { location: 636 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(1) }, Load { destination: Relative(15), source_pointer: Relative(19) }, Cast { destination: Relative(19), source: Relative(15), bit_size: Integer(U128) }, Cast { destination: Relative(17), source: Relative(19), bit_size: Field }, BinaryFieldOp { destination: Relative(19), op: Sub, lhs: Relative(15), rhs: Relative(17) }, BinaryFieldOp { destination: Relative(21), op: Mul, lhs: Relative(19), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(19), op: Mul, lhs: Direct(32842), rhs: Relative(21) }, BinaryFieldOp { destination: Relative(22), op: Add, lhs: Relative(17), rhs: Relative(19) }, BinaryFieldOp { destination: Relative(19), op: Equals, lhs: Relative(15), rhs: Relative(22) }, JumpIf { condition: Relative(19), location: 677 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Load { destination: Relative(15), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(19), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 838 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(19) }, Store { destination_pointer: Relative(24), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 838 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(15) }, Store { destination_pointer: Relative(23), source: Relative(21) }, Store { destination_pointer: Relative(13), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(19) }, Load { destination: Relative(21), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Load { destination: Relative(23), source_pointer: Relative(25) }, Load { destination: Relative(22), source_pointer: Relative(14) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(24), source: Direct(32773) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(15) }, Store { destination_pointer: Relative(26), source: Relative(17) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(21) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 838 }, Mov { destination: Relative(19), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(23) }, Store { destination_pointer: Relative(14), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(15) }, Jump { location: 351 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 740 }, Call { location: 832 }, BinaryIntOp { destination: Relative(2), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(2) }, Load { destination: Relative(8), source_pointer: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 748 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 759 }, Call { location: 832 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Load { destination: Relative(2), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32839) }, JumpIf { condition: Relative(12), location: 766 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, Store { destination_pointer: Relative(15), source: Relative(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 226 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 782 }, Call { location: 832 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 789 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 215 }, Load { destination: Relative(12), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 805 }, Call { location: 832 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 812 }, Call { location: 835 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 838 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, Store { destination_pointer: Relative(11), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32838) }, Mov { destination: Relative(8), source: Relative(12) }, Jump { location: 204 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 828 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 842 }, Jump { location: 844 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 859 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 856 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 849 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 859 }, Return, Call { location: 823 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Load { destination: Relative(2), source_pointer: Relative(3) }, Cast { destination: Relative(3), source: Relative(2), bit_size: Integer(U64) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 56 }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(3), bit_size: Integer(U64) }, Const { destination: Relative(3), bit_size: Integer(U64), value: 48 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 875 }, Call { location: 832 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, Load { destination: Relative(4), source_pointer: Relative(6) }, Cast { destination: Relative(6), source: Relative(4), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 40 }, BinaryIntOp { destination: Relative(7), op: Shl, bit_size: U64, lhs: Relative(6), rhs: Relative(4) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U64, lhs: Relative(5), rhs: Relative(7) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 884 }, Call { location: 832 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, Load { destination: Relative(5), source_pointer: Relative(7) }, Cast { destination: Relative(7), source: Relative(5), bit_size: Integer(U64) }, Const { destination: Relative(5), bit_size: Integer(U64), value: 32 }, BinaryIntOp { destination: Relative(8), op: Shl, bit_size: U64, lhs: Relative(7), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U64, lhs: Relative(6), rhs: Relative(7) }, JumpIf { condition: Relative(9), location: 893 }, Call { location: 832 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32846) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Cast { destination: Relative(8), source: Relative(6), bit_size: Integer(U64) }, Const { destination: Relative(6), bit_size: Integer(U64), value: 24 }, BinaryIntOp { destination: Relative(9), op: Shl, bit_size: U64, lhs: Relative(8), rhs: Relative(6) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U64, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U64, lhs: Relative(7), rhs: Relative(8) }, JumpIf { condition: Relative(10), location: 902 }, Call { location: 832 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, Load { destination: Relative(7), source_pointer: Relative(9) }, Cast { destination: Relative(9), source: Relative(7), bit_size: Integer(U64) }, Const { destination: Relative(7), bit_size: Integer(U64), value: 16 }, BinaryIntOp { destination: Relative(10), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(7) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U64, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 911 }, Call { location: 832 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Cast { destination: Relative(10), source: Relative(8), bit_size: Integer(U64) }, Const { destination: Relative(8), bit_size: Integer(U64), value: 8 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(8) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(10) }, JumpIf { condition: Relative(12), location: 920 }, Call { location: 832 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32849) }, Load { destination: Relative(9), source_pointer: Relative(11) }, Cast { destination: Relative(11), source: Relative(9), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(9) }, JumpIf { condition: Relative(12), location: 927 }, Call { location: 832 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32850) }, Load { destination: Relative(10), source_pointer: Relative(11) }, Cast { destination: Relative(11), source: Relative(10), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(10), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(2) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(11), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(3) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 940 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(4) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 949 }, Call { location: 832 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(11), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(5) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 958 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 967 }, Call { location: 832 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 14 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(11), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(7) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 976 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 15 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(8) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 985 }, Call { location: 832 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Load { destination: Relative(11), source_pointer: Relative(12) }, Cast { destination: Relative(12), source: Relative(11), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 992 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 18 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 1006 }, Call { location: 832 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 19 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(12), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(12), rhs: Relative(4) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1015 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 1024 }, Call { location: 832 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 21 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(12), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(12), rhs: Relative(6) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1033 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 22 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 1042 }, Call { location: 832 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 23 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(12), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(12), rhs: Relative(8) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1051 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 24 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1059 }, Call { location: 832 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 25 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(14) }, Cast { destination: Relative(10), source: Relative(12), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(12), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 26 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Load { destination: Relative(10), source_pointer: Relative(14) }, Cast { destination: Relative(2), source: Relative(10), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(10), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(12), rhs: Relative(10) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U64, lhs: Relative(12), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 1073 }, Call { location: 832 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Load { destination: Relative(10), source_pointer: Relative(12) }, Cast { destination: Relative(3), source: Relative(10), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(10), op: Shl, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(10) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 1082 }, Call { location: 832 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(10) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(5) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1091 }, Call { location: 832 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(3), rhs: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 1100 }, Call { location: 832 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1109 }, Call { location: 832 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U64, lhs: Relative(3), rhs: Relative(8) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 1118 }, Call { location: 832 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32851) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Cast { destination: Relative(1), source: Relative(2), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(3), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U64, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 1125 }, Call { location: 832 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(9) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(13) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Return, Call { location: 823 }, Const { destination: Relative(2), bit_size: Field, value: 64 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Direct(32844) }, Mov { destination: Relative(7), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 1175 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Cast { destination: Relative(4), source: Relative(2), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Mul, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(4), op: Add, lhs: Relative(2), rhs: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(2), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Mul, lhs: Relative(5), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Cast { destination: Relative(1), source: Relative(3), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(2), rhs: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(2) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(4) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Return, Call { location: 823 }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(5), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(4), source: Relative(5) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(8), bit_size: Integer(U1), value: 1 }, Mov { destination: Relative(6), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, BlackBox(ToRadix { input: Relative(2), radix: Relative(7), output_pointer: Relative(9), num_limbs: Relative(10), output_bits: Relative(8) }), Const { destination: Relative(11), bit_size: Integer(U32), value: 32 }, Mov { destination: Direct(32771), source: Relative(9) }, Mov { destination: Direct(32772), source: Relative(11) }, Call { location: 1223 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 33 }, Mov { destination: Relative(3), source: Direct(32838) }, Jump { location: 1196 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 1201 }, Jump { location: 1199 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(7), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(7), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Sub, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(9), location: 1207 }, Call { location: 1242 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Direct(32851) }, JumpIf { condition: Relative(9), location: 1210 }, Call { location: 835 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(7) }, Load { destination: Relative(9), source_pointer: Relative(11) }, Cast { destination: Relative(7), source: Relative(9), bit_size: Field }, BinaryFieldOp { destination: Relative(9), op: Mul, lhs: Relative(8), rhs: Relative(1) }, BinaryFieldOp { destination: Relative(10), op: Mul, lhs: Relative(7), rhs: Relative(9) }, BinaryFieldOp { destination: Relative(9), op: Sub, lhs: Relative(5), rhs: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(9), rhs: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Add, lhs: Relative(10), rhs: Relative(7) }, Store { destination_pointer: Relative(4), source: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Mov { destination: Relative(3), source: Relative(7) }, Jump { location: 1196 }, Const { destination: Direct(32774), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32773), op: Div, bit_size: U32, lhs: Direct(32772), rhs: Direct(32774) }, Mov { destination: Direct(32776), source: Direct(32772) }, Const { destination: Direct(32777), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Direct(32778), op: LessThan, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, Not { destination: Direct(32778), source: Direct(32778), bit_size: U1 }, JumpIf { condition: Direct(32778), location: 1241 }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32777) }, Load { destination: Direct(32774), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32777) }, Store { destination_pointer: Direct(32779), source: Direct(32775) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Store { destination_pointer: Direct(32779), source: Direct(32774) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 1227 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], "debug_symbols": "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", "file_map": { diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_0.snap index 620bd952ce8..989af314fac 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_0.snap @@ -165,7 +165,7 @@ expression: artifact "return value indices : [_184, _185]", "BRILLIG CALL func 0: inputs: [[EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ], EXPR [ (1, _2) 0 ], EXPR [ (1, _3) 0 ], EXPR [ (1, _4) 0 ], EXPR [ (1, _5) 0 ], EXPR [ (1, _6) 0 ], EXPR [ (1, _7) 0 ], EXPR [ (1, _8) 0 ], EXPR [ (1, _9) 0 ], EXPR [ (1, _10) 0 ], EXPR [ (1, _11) 0 ], EXPR [ (1, _12) 0 ], EXPR [ (1, _13) 0 ], EXPR [ (1, _14) 0 ], EXPR [ (1, _15) 0 ], EXPR [ (1, _16) 0 ], EXPR [ (1, _17) 0 ], EXPR [ (1, _18) 0 ], EXPR [ (1, _19) 0 ], EXPR [ (1, _20) 0 ], EXPR [ (1, _21) 0 ], EXPR [ (1, _22) 0 ], EXPR [ (1, _23) 0 ], EXPR [ (1, _24) 0 ], EXPR [ (1, _25) 0 ], EXPR [ (1, _26) 0 ], EXPR [ (1, _27) 0 ], EXPR [ (1, _28) 0 ], EXPR [ (1, _29) 0 ], EXPR [ (1, _30) 0 ], EXPR [ (1, _31) 0 ], EXPR [ (1, _32) 0 ], EXPR [ (1, _33) 0 ], EXPR [ (1, _34) 0 ], EXPR [ (1, _35) 0 ], EXPR [ (1, _36) 0 ], EXPR [ (1, _37) 0 ], EXPR [ (1, _38) 0 ], EXPR [ (1, _39) 0 ], EXPR [ (1, _40) 0 ], EXPR [ (1, _41) 0 ], EXPR [ (1, _42) 0 ], EXPR [ (1, _43) 0 ], EXPR [ (1, _44) 0 ], EXPR [ (1, _45) 0 ], EXPR [ (1, _46) 0 ], EXPR [ (1, _47) 0 ], EXPR [ (1, _48) 0 ], EXPR [ (1, _49) 0 ], EXPR [ (1, _50) 0 ], EXPR [ (1, _51) 0 ], EXPR [ (1, _52) 0 ], EXPR [ (1, _53) 0 ], EXPR [ (1, _54) 0 ], EXPR [ (1, _55) 0 ], EXPR [ (1, _56) 0 ], EXPR [ (1, _57) 0 ], EXPR [ (1, _58) 0 ], EXPR [ (1, _59) 0 ], EXPR [ (1, _60) 0 ], EXPR [ (1, _61) 0 ], EXPR [ (1, _62) 0 ], EXPR [ (1, _63) 0 ]], [EXPR [ (1, _64) 0 ], EXPR [ (1, _65) 0 ], EXPR [ (1, _66) 0 ], EXPR [ (1, _67) 0 ], EXPR [ (1, _68) 0 ], EXPR [ (1, _69) 0 ], EXPR [ (1, _70) 0 ], EXPR [ (1, _71) 0 ], EXPR [ (1, _72) 0 ], EXPR [ (1, _73) 0 ], EXPR [ (1, _74) 0 ], EXPR [ (1, _75) 0 ], EXPR [ (1, _76) 0 ], EXPR [ (1, _77) 0 ], EXPR [ (1, _78) 0 ], EXPR [ (1, _79) 0 ], EXPR [ (1, _80) 0 ], EXPR [ (1, _81) 0 ], EXPR [ (1, _82) 0 ], EXPR [ (1, _83) 0 ], EXPR [ (1, _84) 0 ], EXPR [ (1, _85) 0 ], EXPR [ (1, _86) 0 ], EXPR [ (1, _87) 0 ], EXPR [ (1, _88) 0 ], EXPR [ (1, _89) 0 ], EXPR [ (1, _90) 0 ], EXPR [ (1, _91) 0 ], EXPR [ (1, _92) 0 ], EXPR [ (1, _93) 0 ], EXPR [ (1, _94) 0 ], EXPR [ (1, _95) 0 ], EXPR [ (1, _96) 0 ], EXPR [ (1, _97) 0 ], EXPR [ (1, _98) 0 ], EXPR [ (1, _99) 0 ], EXPR [ (1, _100) 0 ], EXPR [ (1, _101) 0 ], EXPR [ (1, _102) 0 ], EXPR [ (1, _103) 0 ], EXPR [ (1, _104) 0 ], EXPR [ (1, _105) 0 ], EXPR [ (1, _106) 0 ], EXPR [ (1, _107) 0 ], EXPR [ (1, _108) 0 ], EXPR [ (1, _109) 0 ], EXPR [ (1, _110) 0 ], EXPR [ (1, _111) 0 ], EXPR [ (1, _112) 0 ], EXPR [ (1, _113) 0 ], EXPR [ (1, _114) 0 ], EXPR [ (1, _115) 0 ], EXPR [ (1, _116) 0 ], EXPR [ (1, _117) 0 ], EXPR [ (1, _118) 0 ], EXPR [ (1, _119) 0 ], EXPR [ (1, _120) 0 ], EXPR [ (1, _121) 0 ], EXPR [ (1, _122) 0 ], EXPR [ (1, _123) 0 ], EXPR [ (1, _124) 0 ], EXPR [ (1, _125) 0 ], EXPR [ (1, _126) 0 ], EXPR [ (1, _127) 0 ]], [EXPR [ (1, _128) 0 ], EXPR [ (1, _129) 0 ], EXPR [ (1, _130) 0 ], EXPR [ (1, _131) 0 ], EXPR [ (1, _132) 0 ], EXPR [ (1, _133) 0 ], EXPR [ (1, _134) 0 ], EXPR [ (1, _135) 0 ], EXPR [ (1, _136) 0 ], EXPR [ (1, _137) 0 ], EXPR [ (1, _138) 0 ], EXPR [ (1, _139) 0 ], EXPR [ (1, _140) 0 ], EXPR [ (1, _141) 0 ], EXPR [ (1, _142) 0 ], EXPR [ (1, _143) 0 ], EXPR [ (1, _144) 0 ], EXPR [ (1, _145) 0 ], EXPR [ (1, _146) 0 ], EXPR [ (1, _147) 0 ], EXPR [ (1, _148) 0 ], EXPR [ (1, _149) 0 ], EXPR [ (1, _150) 0 ], EXPR [ (1, _151) 0 ], EXPR [ (1, _152) 0 ], EXPR [ (1, _153) 0 ], EXPR [ (1, _154) 0 ], EXPR [ (1, _155) 0 ], EXPR [ (1, _156) 0 ], EXPR [ (1, _157) 0 ], EXPR [ (1, _158) 0 ], EXPR [ (1, _159) 0 ], EXPR [ (1, _160) 0 ], EXPR [ (1, _161) 0 ], EXPR [ (1, _162) 0 ], EXPR [ (1, _163) 0 ], EXPR [ (1, _164) 0 ], EXPR [ (1, _165) 0 ], EXPR [ (1, _166) 0 ], EXPR [ (1, _167) 0 ], EXPR [ (1, _168) 0 ], EXPR [ (1, _169) 0 ], EXPR [ (1, _170) 0 ], EXPR [ (1, _171) 0 ], EXPR [ (1, _172) 0 ], EXPR [ (1, _173) 0 ], EXPR [ (1, _174) 0 ], EXPR [ (1, _175) 0 ]], [EXPR [ (1, _176) 0 ], EXPR [ (1, _177) 0 ]], [EXPR [ (1, _178) 0 ], EXPR [ (1, _179) 0 ]], [EXPR [ (1, _180) 0 ], EXPR [ (1, _181) 0 ]], [EXPR [ (1, _182) 0 ], EXPR [ (1, _183) 0 ]]], outputs: [[_184, _185]]", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 33029 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 184 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32843), size_address: Relative(8), offset_address: Relative(9) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32843 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(1), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32907 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(2), source: Relative(8) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32971 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 48 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 49 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(3), source: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 33019 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(4), source: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33021 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(5), source: Relative(8) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33023 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(6), source: Relative(8) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33025 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(7), source: Relative(8) }, Call { location: 113 }, Call { location: 122 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 33027 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 2 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 102 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 33027 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 112 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 105 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 64 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 16 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 169 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 165 }, Const { destination: Direct(32841), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32842), bit_size: Field, value: 340282366920938463463374607431768211456 }, Return, Call { location: 1195 }, Const { destination: Relative(9), bit_size: Field, value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 170 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 169 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Mov { destination: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 138 }, Store { destination_pointer: Relative(13), source: Relative(9) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Jump { location: 132 }, Mov { destination: Relative(11), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 147 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(2) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 155 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(3) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 163 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 171 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(5) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 179 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(6) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(10) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 187 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(10), source: Relative(18) }, Const { destination: Relative(19), bit_size: Integer(U1), value: 1 }, Mov { destination: Relative(8), source: Relative(18) }, Jump { location: 196 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, JumpIf { condition: Relative(12), location: 1172 }, Jump { location: 199 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 204 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 207 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(8), location: 1149 }, Jump { location: 210 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(12), location: 215 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 219 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 1106 }, Jump { location: 222 }, Load { destination: Relative(3), source_pointer: Relative(10) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 228 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 234 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, JumpIf { condition: Relative(13), location: 245 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(13), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 250 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Store { destination_pointer: Relative(16), source: Relative(13) }, Store { destination_pointer: Relative(11), source: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 262 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(12) }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(4) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(14), source: Relative(13) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(13), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(14) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, Mov { destination: Relative(14), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Const { destination: Relative(12), bit_size: Field, value: 3728882899078719075161482178784387565366481897740339799480980287259621149274 }, Const { destination: Relative(15), bit_size: Field, value: -9903063709032878667290627648209915537972247634463802596148419711785767431332 }, Const { destination: Relative(16), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(17), bit_size: Field, value: 2393473289045184898987089634332637236754766663897650125720167164137088869378 }, Const { destination: Relative(20), bit_size: Field, value: -7135402912423807765050323395026152633898511180575289670895350565966806597339 }, Mov { destination: Relative(21), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(21), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(20) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, Const { destination: Relative(12), bit_size: Field, value: 8680525429001239497728366687280168587232520577698044359798894838135247199343 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 347 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, JumpIf { condition: Relative(15), location: 1036 }, Jump { location: 350 }, Load { destination: Relative(7), source_pointer: Relative(13) }, Const { destination: Relative(12), bit_size: Field, value: 2 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 5 }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Store { destination_pointer: Relative(20), source: Relative(12) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(7) }, Store { destination_pointer: Relative(21), source: Relative(9) }, Store { destination_pointer: Relative(13), source: Relative(20) }, Load { destination: Relative(9), source_pointer: Relative(14) }, Const { destination: Relative(13), bit_size: Field, value: -1094708040843609169356775910874053498301840173462935739639689208799068762676 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 7 }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(13) }, Const { destination: Relative(9), bit_size: Field, value: -718703907181967287621274717949248537252263842169639534402461291799004475262 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 8 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(13) }, Store { destination_pointer: Relative(23), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 9 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(9) }, Store { destination_pointer: Relative(23), source: Relative(16) }, Store { destination_pointer: Relative(14), source: Relative(21) }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BlackBox(MultiScalarMul { points: HeapVector { pointer: Relative(22), size: Relative(23) }, scalars: HeapVector { pointer: Relative(24), size: Relative(25) }, outputs: HeapArray { pointer: Relative(26), size: 3 } }), BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Load { destination: Relative(20), source_pointer: Relative(21) }, Load { destination: Relative(14), source_pointer: Relative(11) }, Load { destination: Relative(21), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(21), rhs: Direct(32839) }, JumpIf { condition: Relative(22), location: 409 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(21) }, Store { destination_pointer: Relative(24), source: Relative(20) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(21), rhs: Relative(14) }, JumpIf { condition: Relative(20), location: 420 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32839) }, JumpIf { condition: Relative(20), location: 423 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(14) }, Store { destination_pointer: Relative(23), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(21), location: 434 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(21), location: 437 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(20) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 448 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Load { destination: Relative(4), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 453 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(3) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(20), location: 464 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Load { destination: Relative(20), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 469 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(5), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(20) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(14), location: 480 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 485 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(4) }, Store { destination_pointer: Relative(21), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 496 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 501 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(6), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(3) }, Store { destination_pointer: Relative(21), source: Relative(5) }, Store { destination_pointer: Relative(11), source: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 513 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 518 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5345 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Mov { destination: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(6) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 533 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 527 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5344 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 540 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32840) }, JumpIf { condition: Relative(6), location: 993 }, Jump { location: 543 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5280 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(10), location: 942 }, Jump { location: 549 }, Load { destination: Relative(4), source_pointer: Relative(3) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BlackBox(Blake2s { message: HeapVector { pointer: Relative(5), size: Relative(6) }, output: HeapArray { pointer: Relative(10), size: 32 } }), BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(4), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 56 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(4) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(10) }, Cast { destination: Relative(10), source: Relative(5), bit_size: Integer(U64) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 48 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(6), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 572 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(11) }, Cast { destination: Relative(2), source: Relative(6), bit_size: Integer(U64) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 40 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(2) }, JumpIf { condition: Relative(14), location: 581 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32841) }, Load { destination: Relative(10), source_pointer: Relative(11) }, Cast { destination: Relative(11), source: Relative(10), bit_size: Integer(U64) }, Const { destination: Relative(10), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(14), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(11) }, JumpIf { condition: Relative(18), location: 590 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(2), source_pointer: Relative(14) }, Cast { destination: Relative(14), source: Relative(2), bit_size: Integer(U64) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 24 }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(14), rhs: Relative(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(14) }, JumpIf { condition: Relative(18), location: 599 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(15) }, Cast { destination: Relative(7), source: Relative(11), bit_size: Integer(U64) }, Const { destination: Relative(11), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(7), rhs: Relative(11) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(14), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(14), rhs: Relative(7) }, JumpIf { condition: Relative(18), location: 608 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(17) }, Load { destination: Relative(14), source_pointer: Relative(15) }, Cast { destination: Relative(15), source: Relative(14), bit_size: Integer(U64) }, Const { destination: Relative(14), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(7), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(7), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 617 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(7), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(7), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(7) }, JumpIf { condition: Relative(17), location: 624 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(9), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(4) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(5) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 637 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(6) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 646 }, Call { location: 1204 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 655 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 664 }, Call { location: 1204 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 14 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 673 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 15 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 682 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32836) }, Load { destination: Relative(9), source_pointer: Relative(15) }, Cast { destination: Relative(15), source: Relative(9), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 689 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(4) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 18 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(5) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 703 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 19 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 712 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 721 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 21 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 730 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 22 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(11) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 739 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 23 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 748 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 24 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, JumpIf { condition: Relative(18), location: 756 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 25 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 26 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(18) }, Cast { destination: Relative(4), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 770 }, Call { location: 1204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(5), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(13) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 779 }, Call { location: 1204 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(13) }, Cast { destination: Relative(4), source: Relative(6), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(10) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U64, lhs: Relative(5), rhs: Relative(4) }, JumpIf { condition: Relative(10), location: 788 }, Call { location: 1204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, Load { destination: Relative(6), source_pointer: Relative(10) }, Cast { destination: Relative(5), source: Relative(6), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 797 }, Call { location: 1204 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Cast { destination: Relative(4), source: Relative(5), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 806 }, Call { location: 1204 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Cast { destination: Relative(2), source: Relative(5), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 815 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 822 }, Call { location: 1204 }, Mov { destination: Relative(2), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(2), source: Relative(3) }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(10), source: Relative(6) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(19) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33 }, Mov { destination: Relative(1), source: Direct(32838) }, Jump { location: 898 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, JumpIf { condition: Relative(10), location: 920 }, Jump { location: 901 }, Load { destination: Relative(1), source_pointer: Relative(2) }, Cast { destination: Relative(2), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(2), rhs: Relative(1) }, Cast { destination: Relative(2), source: Relative(9), bit_size: Field }, BinaryFieldOp { destination: Relative(5), op: Add, lhs: Relative(3), rhs: Relative(2) }, Cast { destination: Relative(2), source: Relative(17), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(2), rhs: Relative(1) }, Cast { destination: Relative(1), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Add, lhs: Relative(3), rhs: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Return, Load { destination: Relative(10), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(11), op: Mul, lhs: Relative(10), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Sub, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 926 }, Call { location: 1232 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 929 }, Call { location: 1207 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Field }, BinaryFieldOp { destination: Relative(13), op: Mul, lhs: Relative(11), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(14), op: Mul, lhs: Relative(10), rhs: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Sub, lhs: Relative(3), rhs: Relative(10) }, BinaryFieldOp { destination: Relative(10), op: Mul, lhs: Relative(13), rhs: Relative(11) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(14), rhs: Relative(10) }, Store { destination_pointer: Relative(2), source: Relative(11) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 898 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, Load { destination: Relative(20), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32839) }, JumpIf { condition: Relative(21), location: 947 }, Call { location: 1207 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(14) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Const { destination: Relative(20), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 16 }, BlackBox(ToRadix { input: Relative(21), radix: Relative(4), output_pointer: Relative(22), num_limbs: Relative(23), output_bits: Relative(20) }), BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(20) }, BinaryIntOp { destination: Relative(22), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(21) }, JumpIf { condition: Relative(22), location: 963 }, Call { location: 1204 }, Mov { destination: Relative(10), source: Relative(18) }, Jump { location: 965 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Direct(32836) }, JumpIf { condition: Relative(20), location: 971 }, Jump { location: 968 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(10) }, BinaryIntOp { destination: Relative(22), op: LessThanEquals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 975 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(10) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Load { destination: Relative(23), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 982 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 1210 }, Mov { destination: Relative(24), source: Direct(32773) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(20) }, Store { destination_pointer: Relative(26), source: Relative(22) }, Store { destination_pointer: Relative(3), source: Relative(24) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(32838) }, Mov { destination: Relative(10), source: Relative(20) }, Jump { location: 965 }, Load { destination: Relative(10), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, Load { destination: Relative(14), source_pointer: Relative(21) }, Const { destination: Relative(20), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 32 }, BlackBox(ToRadix { input: Relative(14), radix: Relative(4), output_pointer: Relative(21), num_limbs: Relative(22), output_bits: Relative(20) }), BinaryIntOp { destination: Relative(14), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(6), source: Relative(18) }, Jump { location: 1008 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(20), location: 1014 }, Jump { location: 1011 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 540 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(6) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(20) }, JumpIf { condition: Relative(21), location: 1018 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(6) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Load { destination: Relative(22), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(5) }, JumpIf { condition: Relative(23), location: 1025 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 1210 }, Mov { destination: Relative(23), source: Direct(32773) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(20) }, Store { destination_pointer: Relative(25), source: Relative(21) }, Store { destination_pointer: Relative(3), source: Relative(23) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Mov { destination: Relative(6), source: Relative(20) }, Jump { location: 1008 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(1) }, Load { destination: Relative(15), source_pointer: Relative(20) }, Cast { destination: Relative(20), source: Relative(15), bit_size: Integer(U128) }, Cast { destination: Relative(17), source: Relative(20), bit_size: Field }, BinaryFieldOp { destination: Relative(20), op: Sub, lhs: Relative(15), rhs: Relative(17) }, BinaryFieldOp { destination: Relative(22), op: Mul, lhs: Relative(20), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(20), op: Mul, lhs: Direct(32842), rhs: Relative(22) }, BinaryFieldOp { destination: Relative(23), op: Add, lhs: Relative(17), rhs: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(15), rhs: Relative(23) }, JumpIf { condition: Relative(20), location: 1049 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(15), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(23), source: Direct(32773) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(20) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(15) }, Store { destination_pointer: Relative(24), source: Relative(22) }, Store { destination_pointer: Relative(13), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(23) }, Load { destination: Relative(24), source_pointer: Relative(26) }, Load { destination: Relative(23), source_pointer: Relative(14) }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(25), source: Direct(32773) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(15) }, Store { destination_pointer: Relative(27), source: Relative(17) }, Mov { destination: Direct(32771), source: Relative(25) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(20) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(17) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Store { destination_pointer: Relative(14), source: Relative(20) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(15) }, Jump { location: 347 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1112 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 1120 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1131 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Load { destination: Relative(8), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(13), location: 1138 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 219 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 1154 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 1161 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 207 }, Load { destination: Relative(12), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1177 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 1184 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, Store { destination_pointer: Relative(11), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32838) }, Mov { destination: Relative(8), source: Relative(12) }, Jump { location: 196 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 1200 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 1214 }, Jump { location: 1216 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 1231 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 1228 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 1221 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 1231 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 33029 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 184 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32843), size_address: Relative(8), offset_address: Relative(9) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32843 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(1), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32907 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(2), source: Relative(8) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32971 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 48 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 49 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(3), source: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 33019 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(4), source: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33021 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(5), source: Relative(8) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33023 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(6), source: Relative(8) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33025 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(7), source: Relative(8) }, Call { location: 113 }, Call { location: 122 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 33027 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 2 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 102 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 33027 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 112 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 105 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 64 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 16 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 169 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 165 }, Const { destination: Direct(32841), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32842), bit_size: Field, value: 340282366920938463463374607431768211456 }, Return, Call { location: 1195 }, Const { destination: Relative(9), bit_size: Field, value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 170 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 169 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Mov { destination: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 138 }, Store { destination_pointer: Relative(13), source: Relative(9) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Jump { location: 132 }, Mov { destination: Relative(11), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 147 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(2) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 155 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(3) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 163 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 171 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(5) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 179 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(6) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(10) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 187 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(10), source: Relative(18) }, Const { destination: Relative(19), bit_size: Integer(U1), value: 1 }, Mov { destination: Relative(8), source: Relative(18) }, Jump { location: 196 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, JumpIf { condition: Relative(12), location: 1172 }, Jump { location: 199 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 204 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 207 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(8), location: 1149 }, Jump { location: 210 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(12), location: 215 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 219 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 1106 }, Jump { location: 222 }, Load { destination: Relative(3), source_pointer: Relative(10) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 228 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 234 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, JumpIf { condition: Relative(13), location: 245 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(13), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 250 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Store { destination_pointer: Relative(16), source: Relative(13) }, Store { destination_pointer: Relative(11), source: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 262 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(12) }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(4) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(14), source: Relative(13) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(13), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(14) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, Mov { destination: Relative(14), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Const { destination: Relative(12), bit_size: Field, value: 3728882899078719075161482178784387565366481897740339799480980287259621149274 }, Const { destination: Relative(15), bit_size: Field, value: -9903063709032878667290627648209915537972247634463802596148419711785767431332 }, Const { destination: Relative(16), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(17), bit_size: Field, value: 2393473289045184898987089634332637236754766663897650125720167164137088869378 }, Const { destination: Relative(20), bit_size: Field, value: -7135402912423807765050323395026152633898511180575289670895350565966806597339 }, Mov { destination: Relative(21), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(21), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(20) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, Const { destination: Relative(12), bit_size: Field, value: 8680525429001239497728366687280168587232520577698044359798894838135247199343 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 347 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, JumpIf { condition: Relative(15), location: 1036 }, Jump { location: 350 }, Load { destination: Relative(7), source_pointer: Relative(13) }, Const { destination: Relative(12), bit_size: Field, value: 2 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 5 }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Store { destination_pointer: Relative(20), source: Relative(12) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(7) }, Store { destination_pointer: Relative(21), source: Relative(9) }, Store { destination_pointer: Relative(13), source: Relative(20) }, Load { destination: Relative(9), source_pointer: Relative(14) }, Const { destination: Relative(13), bit_size: Field, value: -1094708040843609169356775910874053498301840173462935739639689208799068762676 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 7 }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(13) }, Const { destination: Relative(9), bit_size: Field, value: -718703907181967287621274717949248537252263842169639534402461291799004475262 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 8 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(13) }, Store { destination_pointer: Relative(23), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 9 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(9) }, Store { destination_pointer: Relative(23), source: Relative(16) }, Store { destination_pointer: Relative(14), source: Relative(21) }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BlackBox(MultiScalarMul { points: HeapVector { pointer: Relative(22), size: Relative(23) }, scalars: HeapVector { pointer: Relative(24), size: Relative(25) }, outputs: HeapArray { pointer: Relative(26), size: 3 } }), BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Load { destination: Relative(20), source_pointer: Relative(21) }, Load { destination: Relative(14), source_pointer: Relative(11) }, Load { destination: Relative(21), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(21), rhs: Direct(32839) }, JumpIf { condition: Relative(22), location: 409 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(21) }, Store { destination_pointer: Relative(24), source: Relative(20) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(21), rhs: Relative(14) }, JumpIf { condition: Relative(20), location: 420 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32839) }, JumpIf { condition: Relative(20), location: 423 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(14) }, Store { destination_pointer: Relative(23), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(21), location: 434 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(21), location: 437 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(20) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 448 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Load { destination: Relative(4), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 453 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(3) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(20), location: 464 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Load { destination: Relative(20), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 469 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(5), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(20) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(14), location: 480 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 485 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(4) }, Store { destination_pointer: Relative(21), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 496 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 501 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(6), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(3) }, Store { destination_pointer: Relative(21), source: Relative(5) }, Store { destination_pointer: Relative(11), source: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 513 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 518 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5345 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Mov { destination: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(6) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 533 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 527 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5344 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 540 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32840) }, JumpIf { condition: Relative(6), location: 993 }, Jump { location: 543 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5280 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(10), location: 942 }, Jump { location: 549 }, Load { destination: Relative(4), source_pointer: Relative(3) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BlackBox(Blake2s { message: HeapVector { pointer: Relative(5), size: Relative(6) }, output: HeapArray { pointer: Relative(10), size: 32 } }), BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(4), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 56 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(4) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(10) }, Cast { destination: Relative(10), source: Relative(5), bit_size: Integer(U64) }, Const { destination: Relative(5), bit_size: Integer(U64), value: 48 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(6), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 572 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(11) }, Cast { destination: Relative(2), source: Relative(6), bit_size: Integer(U64) }, Const { destination: Relative(6), bit_size: Integer(U64), value: 40 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(2) }, JumpIf { condition: Relative(14), location: 581 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32841) }, Load { destination: Relative(10), source_pointer: Relative(11) }, Cast { destination: Relative(11), source: Relative(10), bit_size: Integer(U64) }, Const { destination: Relative(10), bit_size: Integer(U64), value: 32 }, BinaryIntOp { destination: Relative(14), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(11) }, JumpIf { condition: Relative(18), location: 590 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(2), source_pointer: Relative(14) }, Cast { destination: Relative(14), source: Relative(2), bit_size: Integer(U64) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 24 }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(14), rhs: Relative(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(14) }, JumpIf { condition: Relative(18), location: 599 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(15) }, Cast { destination: Relative(7), source: Relative(11), bit_size: Integer(U64) }, Const { destination: Relative(11), bit_size: Integer(U64), value: 16 }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(7), rhs: Relative(11) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(14), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(14), rhs: Relative(7) }, JumpIf { condition: Relative(18), location: 608 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(17) }, Load { destination: Relative(14), source_pointer: Relative(15) }, Cast { destination: Relative(15), source: Relative(14), bit_size: Integer(U64) }, Const { destination: Relative(14), bit_size: Integer(U64), value: 8 }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(7), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(7), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 617 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(7), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(7), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(7) }, JumpIf { condition: Relative(17), location: 624 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(9), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(4) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(5) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 637 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(6) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 646 }, Call { location: 1204 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 655 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 664 }, Call { location: 1204 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 14 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 673 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 15 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 682 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32836) }, Load { destination: Relative(9), source_pointer: Relative(15) }, Cast { destination: Relative(15), source: Relative(9), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 689 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(4) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 18 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(5) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 703 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 19 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 712 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 721 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 21 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 730 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 22 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(11) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 739 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 23 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 748 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 24 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, JumpIf { condition: Relative(18), location: 756 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 25 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 26 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(18) }, Cast { destination: Relative(4), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 770 }, Call { location: 1204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(5), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(13) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 779 }, Call { location: 1204 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(13) }, Cast { destination: Relative(4), source: Relative(6), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(10) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U64, lhs: Relative(5), rhs: Relative(4) }, JumpIf { condition: Relative(10), location: 788 }, Call { location: 1204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, Load { destination: Relative(6), source_pointer: Relative(10) }, Cast { destination: Relative(5), source: Relative(6), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 797 }, Call { location: 1204 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Cast { destination: Relative(4), source: Relative(5), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 806 }, Call { location: 1204 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Cast { destination: Relative(2), source: Relative(5), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 815 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 822 }, Call { location: 1204 }, Mov { destination: Relative(2), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(2), source: Relative(3) }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(10), source: Relative(6) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(19) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33 }, Mov { destination: Relative(1), source: Direct(32838) }, Jump { location: 898 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, JumpIf { condition: Relative(10), location: 920 }, Jump { location: 901 }, Load { destination: Relative(1), source_pointer: Relative(2) }, Cast { destination: Relative(2), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(2), rhs: Relative(1) }, Cast { destination: Relative(2), source: Relative(9), bit_size: Field }, BinaryFieldOp { destination: Relative(5), op: Add, lhs: Relative(3), rhs: Relative(2) }, Cast { destination: Relative(2), source: Relative(17), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(2), rhs: Relative(1) }, Cast { destination: Relative(1), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Add, lhs: Relative(3), rhs: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Return, Load { destination: Relative(10), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(11), op: Mul, lhs: Relative(10), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Sub, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 926 }, Call { location: 1232 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 929 }, Call { location: 1207 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Field }, BinaryFieldOp { destination: Relative(13), op: Mul, lhs: Relative(11), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(14), op: Mul, lhs: Relative(10), rhs: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Sub, lhs: Relative(3), rhs: Relative(10) }, BinaryFieldOp { destination: Relative(10), op: Mul, lhs: Relative(13), rhs: Relative(11) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(14), rhs: Relative(10) }, Store { destination_pointer: Relative(2), source: Relative(11) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 898 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, Load { destination: Relative(20), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32839) }, JumpIf { condition: Relative(21), location: 947 }, Call { location: 1207 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(14) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Const { destination: Relative(20), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 16 }, BlackBox(ToRadix { input: Relative(21), radix: Relative(4), output_pointer: Relative(22), num_limbs: Relative(23), output_bits: Relative(20) }), BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(20) }, BinaryIntOp { destination: Relative(22), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(21) }, JumpIf { condition: Relative(22), location: 963 }, Call { location: 1204 }, Mov { destination: Relative(10), source: Relative(18) }, Jump { location: 965 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Direct(32836) }, JumpIf { condition: Relative(20), location: 971 }, Jump { location: 968 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(10) }, BinaryIntOp { destination: Relative(22), op: LessThanEquals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 975 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(10) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Load { destination: Relative(23), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 982 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 1210 }, Mov { destination: Relative(24), source: Direct(32773) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(20) }, Store { destination_pointer: Relative(26), source: Relative(22) }, Store { destination_pointer: Relative(3), source: Relative(24) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(32838) }, Mov { destination: Relative(10), source: Relative(20) }, Jump { location: 965 }, Load { destination: Relative(10), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, Load { destination: Relative(14), source_pointer: Relative(21) }, Const { destination: Relative(20), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 32 }, BlackBox(ToRadix { input: Relative(14), radix: Relative(4), output_pointer: Relative(21), num_limbs: Relative(22), output_bits: Relative(20) }), BinaryIntOp { destination: Relative(14), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(6), source: Relative(18) }, Jump { location: 1008 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(20), location: 1014 }, Jump { location: 1011 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 540 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(6) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(20) }, JumpIf { condition: Relative(21), location: 1018 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(6) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Load { destination: Relative(22), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(5) }, JumpIf { condition: Relative(23), location: 1025 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 1210 }, Mov { destination: Relative(23), source: Direct(32773) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(20) }, Store { destination_pointer: Relative(25), source: Relative(21) }, Store { destination_pointer: Relative(3), source: Relative(23) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Mov { destination: Relative(6), source: Relative(20) }, Jump { location: 1008 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(1) }, Load { destination: Relative(15), source_pointer: Relative(20) }, Cast { destination: Relative(20), source: Relative(15), bit_size: Integer(U128) }, Cast { destination: Relative(17), source: Relative(20), bit_size: Field }, BinaryFieldOp { destination: Relative(20), op: Sub, lhs: Relative(15), rhs: Relative(17) }, BinaryFieldOp { destination: Relative(22), op: Mul, lhs: Relative(20), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(20), op: Mul, lhs: Direct(32842), rhs: Relative(22) }, BinaryFieldOp { destination: Relative(23), op: Add, lhs: Relative(17), rhs: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(15), rhs: Relative(23) }, JumpIf { condition: Relative(20), location: 1049 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(15), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(23), source: Direct(32773) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(20) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(15) }, Store { destination_pointer: Relative(24), source: Relative(22) }, Store { destination_pointer: Relative(13), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(23) }, Load { destination: Relative(24), source_pointer: Relative(26) }, Load { destination: Relative(23), source_pointer: Relative(14) }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(25), source: Direct(32773) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(15) }, Store { destination_pointer: Relative(27), source: Relative(17) }, Mov { destination: Direct(32771), source: Relative(25) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(20) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(17) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Store { destination_pointer: Relative(14), source: Relative(20) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(15) }, Jump { location: 347 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1112 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 1120 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1131 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Load { destination: Relative(8), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(13), location: 1138 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 219 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 1154 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 1161 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 207 }, Load { destination: Relative(12), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1177 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 1184 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, Store { destination_pointer: Relative(11), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32838) }, Mov { destination: Relative(8), source: Relative(12) }, Jump { location: 196 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 1200 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 1214 }, Jump { location: 1216 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 1231 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 1228 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 1221 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 1231 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], "debug_symbols": "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", "file_map": { diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 620bd952ce8..989af314fac 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -165,7 +165,7 @@ expression: artifact "return value indices : [_184, _185]", "BRILLIG CALL func 0: inputs: [[EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ], EXPR [ (1, _2) 0 ], EXPR [ (1, _3) 0 ], EXPR [ (1, _4) 0 ], EXPR [ (1, _5) 0 ], EXPR [ (1, _6) 0 ], EXPR [ (1, _7) 0 ], EXPR [ (1, _8) 0 ], EXPR [ (1, _9) 0 ], EXPR [ (1, _10) 0 ], EXPR [ (1, _11) 0 ], EXPR [ (1, _12) 0 ], EXPR [ (1, _13) 0 ], EXPR [ (1, _14) 0 ], EXPR [ (1, _15) 0 ], EXPR [ (1, _16) 0 ], EXPR [ (1, _17) 0 ], EXPR [ (1, _18) 0 ], EXPR [ (1, _19) 0 ], EXPR [ (1, _20) 0 ], EXPR [ (1, _21) 0 ], EXPR [ (1, _22) 0 ], EXPR [ (1, _23) 0 ], EXPR [ (1, _24) 0 ], EXPR [ (1, _25) 0 ], EXPR [ (1, _26) 0 ], EXPR [ (1, _27) 0 ], EXPR [ (1, _28) 0 ], EXPR [ (1, _29) 0 ], EXPR [ (1, _30) 0 ], EXPR [ (1, _31) 0 ], EXPR [ (1, _32) 0 ], EXPR [ (1, _33) 0 ], EXPR [ (1, _34) 0 ], EXPR [ (1, _35) 0 ], EXPR [ (1, _36) 0 ], EXPR [ (1, _37) 0 ], EXPR [ (1, _38) 0 ], EXPR [ (1, _39) 0 ], EXPR [ (1, _40) 0 ], EXPR [ (1, _41) 0 ], EXPR [ (1, _42) 0 ], EXPR [ (1, _43) 0 ], EXPR [ (1, _44) 0 ], EXPR [ (1, _45) 0 ], EXPR [ (1, _46) 0 ], EXPR [ (1, _47) 0 ], EXPR [ (1, _48) 0 ], EXPR [ (1, _49) 0 ], EXPR [ (1, _50) 0 ], EXPR [ (1, _51) 0 ], EXPR [ (1, _52) 0 ], EXPR [ (1, _53) 0 ], EXPR [ (1, _54) 0 ], EXPR [ (1, _55) 0 ], EXPR [ (1, _56) 0 ], EXPR [ (1, _57) 0 ], EXPR [ (1, _58) 0 ], EXPR [ (1, _59) 0 ], EXPR [ (1, _60) 0 ], EXPR [ (1, _61) 0 ], EXPR [ (1, _62) 0 ], EXPR [ (1, _63) 0 ]], [EXPR [ (1, _64) 0 ], EXPR [ (1, _65) 0 ], EXPR [ (1, _66) 0 ], EXPR [ (1, _67) 0 ], EXPR [ (1, _68) 0 ], EXPR [ (1, _69) 0 ], EXPR [ (1, _70) 0 ], EXPR [ (1, _71) 0 ], EXPR [ (1, _72) 0 ], EXPR [ (1, _73) 0 ], EXPR [ (1, _74) 0 ], EXPR [ (1, _75) 0 ], EXPR [ (1, _76) 0 ], EXPR [ (1, _77) 0 ], EXPR [ (1, _78) 0 ], EXPR [ (1, _79) 0 ], EXPR [ (1, _80) 0 ], EXPR [ (1, _81) 0 ], EXPR [ (1, _82) 0 ], EXPR [ (1, _83) 0 ], EXPR [ (1, _84) 0 ], EXPR [ (1, _85) 0 ], EXPR [ (1, _86) 0 ], EXPR [ (1, _87) 0 ], EXPR [ (1, _88) 0 ], EXPR [ (1, _89) 0 ], EXPR [ (1, _90) 0 ], EXPR [ (1, _91) 0 ], EXPR [ (1, _92) 0 ], EXPR [ (1, _93) 0 ], EXPR [ (1, _94) 0 ], EXPR [ (1, _95) 0 ], EXPR [ (1, _96) 0 ], EXPR [ (1, _97) 0 ], EXPR [ (1, _98) 0 ], EXPR [ (1, _99) 0 ], EXPR [ (1, _100) 0 ], EXPR [ (1, _101) 0 ], EXPR [ (1, _102) 0 ], EXPR [ (1, _103) 0 ], EXPR [ (1, _104) 0 ], EXPR [ (1, _105) 0 ], EXPR [ (1, _106) 0 ], EXPR [ (1, _107) 0 ], EXPR [ (1, _108) 0 ], EXPR [ (1, _109) 0 ], EXPR [ (1, _110) 0 ], EXPR [ (1, _111) 0 ], EXPR [ (1, _112) 0 ], EXPR [ (1, _113) 0 ], EXPR [ (1, _114) 0 ], EXPR [ (1, _115) 0 ], EXPR [ (1, _116) 0 ], EXPR [ (1, _117) 0 ], EXPR [ (1, _118) 0 ], EXPR [ (1, _119) 0 ], EXPR [ (1, _120) 0 ], EXPR [ (1, _121) 0 ], EXPR [ (1, _122) 0 ], EXPR [ (1, _123) 0 ], EXPR [ (1, _124) 0 ], EXPR [ (1, _125) 0 ], EXPR [ (1, _126) 0 ], EXPR [ (1, _127) 0 ]], [EXPR [ (1, _128) 0 ], EXPR [ (1, _129) 0 ], EXPR [ (1, _130) 0 ], EXPR [ (1, _131) 0 ], EXPR [ (1, _132) 0 ], EXPR [ (1, _133) 0 ], EXPR [ (1, _134) 0 ], EXPR [ (1, _135) 0 ], EXPR [ (1, _136) 0 ], EXPR [ (1, _137) 0 ], EXPR [ (1, _138) 0 ], EXPR [ (1, _139) 0 ], EXPR [ (1, _140) 0 ], EXPR [ (1, _141) 0 ], EXPR [ (1, _142) 0 ], EXPR [ (1, _143) 0 ], EXPR [ (1, _144) 0 ], EXPR [ (1, _145) 0 ], EXPR [ (1, _146) 0 ], EXPR [ (1, _147) 0 ], EXPR [ (1, _148) 0 ], EXPR [ (1, _149) 0 ], EXPR [ (1, _150) 0 ], EXPR [ (1, _151) 0 ], EXPR [ (1, _152) 0 ], EXPR [ (1, _153) 0 ], EXPR [ (1, _154) 0 ], EXPR [ (1, _155) 0 ], EXPR [ (1, _156) 0 ], EXPR [ (1, _157) 0 ], EXPR [ (1, _158) 0 ], EXPR [ (1, _159) 0 ], EXPR [ (1, _160) 0 ], EXPR [ (1, _161) 0 ], EXPR [ (1, _162) 0 ], EXPR [ (1, _163) 0 ], EXPR [ (1, _164) 0 ], EXPR [ (1, _165) 0 ], EXPR [ (1, _166) 0 ], EXPR [ (1, _167) 0 ], EXPR [ (1, _168) 0 ], EXPR [ (1, _169) 0 ], EXPR [ (1, _170) 0 ], EXPR [ (1, _171) 0 ], EXPR [ (1, _172) 0 ], EXPR [ (1, _173) 0 ], EXPR [ (1, _174) 0 ], EXPR [ (1, _175) 0 ]], [EXPR [ (1, _176) 0 ], EXPR [ (1, _177) 0 ]], [EXPR [ (1, _178) 0 ], EXPR [ (1, _179) 0 ]], [EXPR [ (1, _180) 0 ], EXPR [ (1, _181) 0 ]], [EXPR [ (1, _182) 0 ], EXPR [ (1, _183) 0 ]]], outputs: [[_184, _185]]", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 33029 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 184 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32843), size_address: Relative(8), offset_address: Relative(9) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32843 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(1), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32907 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(2), source: Relative(8) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32971 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 48 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 49 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(3), source: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 33019 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(4), source: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33021 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(5), source: Relative(8) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33023 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(6), source: Relative(8) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33025 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(7), source: Relative(8) }, Call { location: 113 }, Call { location: 122 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 33027 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 2 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 102 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 33027 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 112 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 105 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 64 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 16 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 169 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 165 }, Const { destination: Direct(32841), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32842), bit_size: Field, value: 340282366920938463463374607431768211456 }, Return, Call { location: 1195 }, Const { destination: Relative(9), bit_size: Field, value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 170 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 169 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Mov { destination: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 138 }, Store { destination_pointer: Relative(13), source: Relative(9) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Jump { location: 132 }, Mov { destination: Relative(11), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 147 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(2) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 155 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(3) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 163 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 171 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(5) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 179 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(6) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(10) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 187 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(10), source: Relative(18) }, Const { destination: Relative(19), bit_size: Integer(U1), value: 1 }, Mov { destination: Relative(8), source: Relative(18) }, Jump { location: 196 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, JumpIf { condition: Relative(12), location: 1172 }, Jump { location: 199 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 204 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 207 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(8), location: 1149 }, Jump { location: 210 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(12), location: 215 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 219 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 1106 }, Jump { location: 222 }, Load { destination: Relative(3), source_pointer: Relative(10) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 228 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 234 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, JumpIf { condition: Relative(13), location: 245 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(13), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 250 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Store { destination_pointer: Relative(16), source: Relative(13) }, Store { destination_pointer: Relative(11), source: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 262 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(12) }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(4) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(14), source: Relative(13) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(13), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(14) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, Mov { destination: Relative(14), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Const { destination: Relative(12), bit_size: Field, value: 3728882899078719075161482178784387565366481897740339799480980287259621149274 }, Const { destination: Relative(15), bit_size: Field, value: -9903063709032878667290627648209915537972247634463802596148419711785767431332 }, Const { destination: Relative(16), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(17), bit_size: Field, value: 2393473289045184898987089634332637236754766663897650125720167164137088869378 }, Const { destination: Relative(20), bit_size: Field, value: -7135402912423807765050323395026152633898511180575289670895350565966806597339 }, Mov { destination: Relative(21), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(21), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(20) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, Const { destination: Relative(12), bit_size: Field, value: 8680525429001239497728366687280168587232520577698044359798894838135247199343 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 347 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, JumpIf { condition: Relative(15), location: 1036 }, Jump { location: 350 }, Load { destination: Relative(7), source_pointer: Relative(13) }, Const { destination: Relative(12), bit_size: Field, value: 2 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 5 }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Store { destination_pointer: Relative(20), source: Relative(12) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(7) }, Store { destination_pointer: Relative(21), source: Relative(9) }, Store { destination_pointer: Relative(13), source: Relative(20) }, Load { destination: Relative(9), source_pointer: Relative(14) }, Const { destination: Relative(13), bit_size: Field, value: -1094708040843609169356775910874053498301840173462935739639689208799068762676 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 7 }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(13) }, Const { destination: Relative(9), bit_size: Field, value: -718703907181967287621274717949248537252263842169639534402461291799004475262 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 8 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(13) }, Store { destination_pointer: Relative(23), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 9 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(9) }, Store { destination_pointer: Relative(23), source: Relative(16) }, Store { destination_pointer: Relative(14), source: Relative(21) }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BlackBox(MultiScalarMul { points: HeapVector { pointer: Relative(22), size: Relative(23) }, scalars: HeapVector { pointer: Relative(24), size: Relative(25) }, outputs: HeapArray { pointer: Relative(26), size: 3 } }), BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Load { destination: Relative(20), source_pointer: Relative(21) }, Load { destination: Relative(14), source_pointer: Relative(11) }, Load { destination: Relative(21), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(21), rhs: Direct(32839) }, JumpIf { condition: Relative(22), location: 409 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(21) }, Store { destination_pointer: Relative(24), source: Relative(20) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(21), rhs: Relative(14) }, JumpIf { condition: Relative(20), location: 420 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32839) }, JumpIf { condition: Relative(20), location: 423 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(14) }, Store { destination_pointer: Relative(23), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(21), location: 434 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(21), location: 437 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(20) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 448 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Load { destination: Relative(4), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 453 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(3) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(20), location: 464 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Load { destination: Relative(20), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 469 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(5), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(20) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(14), location: 480 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 485 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(4) }, Store { destination_pointer: Relative(21), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 496 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 501 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(6), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(3) }, Store { destination_pointer: Relative(21), source: Relative(5) }, Store { destination_pointer: Relative(11), source: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 513 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 518 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5345 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Mov { destination: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(6) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 533 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 527 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5344 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 540 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32840) }, JumpIf { condition: Relative(6), location: 993 }, Jump { location: 543 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5280 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(10), location: 942 }, Jump { location: 549 }, Load { destination: Relative(4), source_pointer: Relative(3) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BlackBox(Blake2s { message: HeapVector { pointer: Relative(5), size: Relative(6) }, output: HeapArray { pointer: Relative(10), size: 32 } }), BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(4), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 56 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(4) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(10) }, Cast { destination: Relative(10), source: Relative(5), bit_size: Integer(U64) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 48 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(6), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 572 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(11) }, Cast { destination: Relative(2), source: Relative(6), bit_size: Integer(U64) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 40 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(2) }, JumpIf { condition: Relative(14), location: 581 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32841) }, Load { destination: Relative(10), source_pointer: Relative(11) }, Cast { destination: Relative(11), source: Relative(10), bit_size: Integer(U64) }, Const { destination: Relative(10), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(14), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(11) }, JumpIf { condition: Relative(18), location: 590 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(2), source_pointer: Relative(14) }, Cast { destination: Relative(14), source: Relative(2), bit_size: Integer(U64) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 24 }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(14), rhs: Relative(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(14) }, JumpIf { condition: Relative(18), location: 599 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(15) }, Cast { destination: Relative(7), source: Relative(11), bit_size: Integer(U64) }, Const { destination: Relative(11), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(7), rhs: Relative(11) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(14), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(14), rhs: Relative(7) }, JumpIf { condition: Relative(18), location: 608 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(17) }, Load { destination: Relative(14), source_pointer: Relative(15) }, Cast { destination: Relative(15), source: Relative(14), bit_size: Integer(U64) }, Const { destination: Relative(14), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(7), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(7), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 617 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(7), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(7), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(7) }, JumpIf { condition: Relative(17), location: 624 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(9), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(4) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(5) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 637 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(6) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 646 }, Call { location: 1204 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 655 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 664 }, Call { location: 1204 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 14 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 673 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 15 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 682 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32836) }, Load { destination: Relative(9), source_pointer: Relative(15) }, Cast { destination: Relative(15), source: Relative(9), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 689 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(4) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 18 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(5) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 703 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 19 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 712 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 721 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 21 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 730 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 22 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(11) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 739 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 23 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 748 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 24 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, JumpIf { condition: Relative(18), location: 756 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 25 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 26 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(18) }, Cast { destination: Relative(4), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 770 }, Call { location: 1204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(5), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(13) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 779 }, Call { location: 1204 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(13) }, Cast { destination: Relative(4), source: Relative(6), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(10) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U64, lhs: Relative(5), rhs: Relative(4) }, JumpIf { condition: Relative(10), location: 788 }, Call { location: 1204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, Load { destination: Relative(6), source_pointer: Relative(10) }, Cast { destination: Relative(5), source: Relative(6), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 797 }, Call { location: 1204 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Cast { destination: Relative(4), source: Relative(5), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 806 }, Call { location: 1204 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Cast { destination: Relative(2), source: Relative(5), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 815 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 822 }, Call { location: 1204 }, Mov { destination: Relative(2), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(2), source: Relative(3) }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(10), source: Relative(6) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(19) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33 }, Mov { destination: Relative(1), source: Direct(32838) }, Jump { location: 898 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, JumpIf { condition: Relative(10), location: 920 }, Jump { location: 901 }, Load { destination: Relative(1), source_pointer: Relative(2) }, Cast { destination: Relative(2), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(2), rhs: Relative(1) }, Cast { destination: Relative(2), source: Relative(9), bit_size: Field }, BinaryFieldOp { destination: Relative(5), op: Add, lhs: Relative(3), rhs: Relative(2) }, Cast { destination: Relative(2), source: Relative(17), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(2), rhs: Relative(1) }, Cast { destination: Relative(1), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Add, lhs: Relative(3), rhs: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Return, Load { destination: Relative(10), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(11), op: Mul, lhs: Relative(10), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Sub, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 926 }, Call { location: 1232 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 929 }, Call { location: 1207 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Field }, BinaryFieldOp { destination: Relative(13), op: Mul, lhs: Relative(11), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(14), op: Mul, lhs: Relative(10), rhs: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Sub, lhs: Relative(3), rhs: Relative(10) }, BinaryFieldOp { destination: Relative(10), op: Mul, lhs: Relative(13), rhs: Relative(11) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(14), rhs: Relative(10) }, Store { destination_pointer: Relative(2), source: Relative(11) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 898 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, Load { destination: Relative(20), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32839) }, JumpIf { condition: Relative(21), location: 947 }, Call { location: 1207 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(14) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Const { destination: Relative(20), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 16 }, BlackBox(ToRadix { input: Relative(21), radix: Relative(4), output_pointer: Relative(22), num_limbs: Relative(23), output_bits: Relative(20) }), BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(20) }, BinaryIntOp { destination: Relative(22), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(21) }, JumpIf { condition: Relative(22), location: 963 }, Call { location: 1204 }, Mov { destination: Relative(10), source: Relative(18) }, Jump { location: 965 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Direct(32836) }, JumpIf { condition: Relative(20), location: 971 }, Jump { location: 968 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(10) }, BinaryIntOp { destination: Relative(22), op: LessThanEquals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 975 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(10) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Load { destination: Relative(23), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 982 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 1210 }, Mov { destination: Relative(24), source: Direct(32773) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(20) }, Store { destination_pointer: Relative(26), source: Relative(22) }, Store { destination_pointer: Relative(3), source: Relative(24) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(32838) }, Mov { destination: Relative(10), source: Relative(20) }, Jump { location: 965 }, Load { destination: Relative(10), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, Load { destination: Relative(14), source_pointer: Relative(21) }, Const { destination: Relative(20), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 32 }, BlackBox(ToRadix { input: Relative(14), radix: Relative(4), output_pointer: Relative(21), num_limbs: Relative(22), output_bits: Relative(20) }), BinaryIntOp { destination: Relative(14), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(6), source: Relative(18) }, Jump { location: 1008 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(20), location: 1014 }, Jump { location: 1011 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 540 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(6) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(20) }, JumpIf { condition: Relative(21), location: 1018 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(6) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Load { destination: Relative(22), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(5) }, JumpIf { condition: Relative(23), location: 1025 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 1210 }, Mov { destination: Relative(23), source: Direct(32773) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(20) }, Store { destination_pointer: Relative(25), source: Relative(21) }, Store { destination_pointer: Relative(3), source: Relative(23) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Mov { destination: Relative(6), source: Relative(20) }, Jump { location: 1008 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(1) }, Load { destination: Relative(15), source_pointer: Relative(20) }, Cast { destination: Relative(20), source: Relative(15), bit_size: Integer(U128) }, Cast { destination: Relative(17), source: Relative(20), bit_size: Field }, BinaryFieldOp { destination: Relative(20), op: Sub, lhs: Relative(15), rhs: Relative(17) }, BinaryFieldOp { destination: Relative(22), op: Mul, lhs: Relative(20), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(20), op: Mul, lhs: Direct(32842), rhs: Relative(22) }, BinaryFieldOp { destination: Relative(23), op: Add, lhs: Relative(17), rhs: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(15), rhs: Relative(23) }, JumpIf { condition: Relative(20), location: 1049 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(15), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(23), source: Direct(32773) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(20) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(15) }, Store { destination_pointer: Relative(24), source: Relative(22) }, Store { destination_pointer: Relative(13), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(23) }, Load { destination: Relative(24), source_pointer: Relative(26) }, Load { destination: Relative(23), source_pointer: Relative(14) }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(25), source: Direct(32773) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(15) }, Store { destination_pointer: Relative(27), source: Relative(17) }, Mov { destination: Direct(32771), source: Relative(25) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(20) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(17) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Store { destination_pointer: Relative(14), source: Relative(20) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(15) }, Jump { location: 347 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1112 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 1120 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1131 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Load { destination: Relative(8), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(13), location: 1138 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 219 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 1154 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 1161 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 207 }, Load { destination: Relative(12), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1177 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 1184 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, Store { destination_pointer: Relative(11), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32838) }, Mov { destination: Relative(8), source: Relative(12) }, Jump { location: 196 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 1200 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 1214 }, Jump { location: 1216 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 1231 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 1228 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 1221 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 1231 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 33029 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 184 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32843), size_address: Relative(8), offset_address: Relative(9) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32843 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(1), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32907 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 64 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 65 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(2), source: Relative(8) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32971 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 48 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 49 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(3), source: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 33019 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(4), source: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33021 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(5), source: Relative(8) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33023 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(6), source: Relative(8) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33025 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(9) }, Call { location: 102 }, Mov { destination: Relative(7), source: Relative(8) }, Call { location: 113 }, Call { location: 122 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 33027 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 2 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 102 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 33027 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 112 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 105 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 64 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 16 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 169 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 165 }, Const { destination: Direct(32841), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32842), bit_size: Field, value: 340282366920938463463374607431768211456 }, Return, Call { location: 1195 }, Const { destination: Relative(9), bit_size: Field, value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 170 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 169 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Mov { destination: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 138 }, Store { destination_pointer: Relative(13), source: Relative(9) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Jump { location: 132 }, Mov { destination: Relative(11), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 147 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(2) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 155 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(3) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 163 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 171 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(5) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 179 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Load { destination: Relative(10), source_pointer: Relative(6) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(10) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 187 }, Call { location: 1201 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(10), source: Relative(18) }, Const { destination: Relative(19), bit_size: Integer(U1), value: 1 }, Mov { destination: Relative(8), source: Relative(18) }, Jump { location: 196 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, JumpIf { condition: Relative(12), location: 1172 }, Jump { location: 199 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 204 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 207 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(8), location: 1149 }, Jump { location: 210 }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(12), location: 215 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 219 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 1106 }, Jump { location: 222 }, Load { destination: Relative(3), source_pointer: Relative(10) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 228 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 234 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, JumpIf { condition: Relative(13), location: 245 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(13), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 250 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Store { destination_pointer: Relative(16), source: Relative(13) }, Store { destination_pointer: Relative(11), source: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 262 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(12) }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(4) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(14), source: Relative(13) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(13), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, IndirectConst { destination_pointer: Relative(12), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(14) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(19) }, Mov { destination: Relative(14), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Const { destination: Relative(12), bit_size: Field, value: 3728882899078719075161482178784387565366481897740339799480980287259621149274 }, Const { destination: Relative(15), bit_size: Field, value: -9903063709032878667290627648209915537972247634463802596148419711785767431332 }, Const { destination: Relative(16), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(17), bit_size: Field, value: 2393473289045184898987089634332637236754766663897650125720167164137088869378 }, Const { destination: Relative(20), bit_size: Field, value: -7135402912423807765050323395026152633898511180575289670895350565966806597339 }, Mov { destination: Relative(21), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(21), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(20) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, Const { destination: Relative(12), bit_size: Field, value: 8680525429001239497728366687280168587232520577698044359798894838135247199343 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 347 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, JumpIf { condition: Relative(15), location: 1036 }, Jump { location: 350 }, Load { destination: Relative(7), source_pointer: Relative(13) }, Const { destination: Relative(12), bit_size: Field, value: 2 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 5 }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Store { destination_pointer: Relative(20), source: Relative(12) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(7) }, Store { destination_pointer: Relative(21), source: Relative(9) }, Store { destination_pointer: Relative(13), source: Relative(20) }, Load { destination: Relative(9), source_pointer: Relative(14) }, Const { destination: Relative(13), bit_size: Field, value: -1094708040843609169356775910874053498301840173462935739639689208799068762676 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 7 }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(13) }, Const { destination: Relative(9), bit_size: Field, value: -718703907181967287621274717949248537252263842169639534402461291799004475262 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 8 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(13) }, Store { destination_pointer: Relative(23), source: Relative(9) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 9 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(9) }, Store { destination_pointer: Relative(23), source: Relative(16) }, Store { destination_pointer: Relative(14), source: Relative(21) }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BlackBox(MultiScalarMul { points: HeapVector { pointer: Relative(22), size: Relative(23) }, scalars: HeapVector { pointer: Relative(24), size: Relative(25) }, outputs: HeapArray { pointer: Relative(26), size: 3 } }), BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Load { destination: Relative(20), source_pointer: Relative(21) }, Load { destination: Relative(14), source_pointer: Relative(11) }, Load { destination: Relative(21), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(21), rhs: Direct(32839) }, JumpIf { condition: Relative(22), location: 409 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(22), source: Direct(32773) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(21) }, Store { destination_pointer: Relative(24), source: Relative(20) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(21), rhs: Relative(14) }, JumpIf { condition: Relative(20), location: 420 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32839) }, JumpIf { condition: Relative(20), location: 423 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(14) }, Store { destination_pointer: Relative(23), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(21), location: 434 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(21), location: 437 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(20) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 448 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32838) }, Load { destination: Relative(4), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 453 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(3) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(20), location: 464 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Load { destination: Relative(20), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 469 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(5), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(20) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(14), location: 480 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Load { destination: Relative(3), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 485 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(4) }, Store { destination_pointer: Relative(21), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 496 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 501 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(6), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(3) }, Store { destination_pointer: Relative(21), source: Relative(5) }, Store { destination_pointer: Relative(11), source: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 513 }, Call { location: 1204 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(4), location: 518 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5345 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Mov { destination: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(6) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 533 }, Store { destination_pointer: Relative(10), source: Relative(3) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 527 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5344 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 540 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32840) }, JumpIf { condition: Relative(6), location: 993 }, Jump { location: 543 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5280 }, Mov { destination: Relative(1), source: Relative(18) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(10), location: 942 }, Jump { location: 549 }, Load { destination: Relative(4), source_pointer: Relative(3) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5344 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BlackBox(Blake2s { message: HeapVector { pointer: Relative(5), size: Relative(6) }, output: HeapArray { pointer: Relative(10), size: 32 } }), BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(5), source: Relative(4), bit_size: Integer(U64) }, Const { destination: Relative(4), bit_size: Integer(U64), value: 56 }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(4) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(10) }, Cast { destination: Relative(10), source: Relative(5), bit_size: Integer(U64) }, Const { destination: Relative(5), bit_size: Integer(U64), value: 48 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(10), rhs: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U64, lhs: Relative(6), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 572 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(11) }, Cast { destination: Relative(2), source: Relative(6), bit_size: Integer(U64) }, Const { destination: Relative(6), bit_size: Integer(U64), value: 40 }, BinaryIntOp { destination: Relative(11), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(10), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U64, lhs: Relative(10), rhs: Relative(2) }, JumpIf { condition: Relative(14), location: 581 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32841) }, Load { destination: Relative(10), source_pointer: Relative(11) }, Cast { destination: Relative(11), source: Relative(10), bit_size: Integer(U64) }, Const { destination: Relative(10), bit_size: Integer(U64), value: 32 }, BinaryIntOp { destination: Relative(14), op: Shl, bit_size: U64, lhs: Relative(11), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(11) }, JumpIf { condition: Relative(18), location: 590 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(2), source_pointer: Relative(14) }, Cast { destination: Relative(14), source: Relative(2), bit_size: Integer(U64) }, Const { destination: Relative(2), bit_size: Integer(U64), value: 24 }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(14), rhs: Relative(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U64, lhs: Relative(11), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(11), rhs: Relative(14) }, JumpIf { condition: Relative(18), location: 599 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(15) }, Cast { destination: Relative(7), source: Relative(11), bit_size: Integer(U64) }, Const { destination: Relative(11), bit_size: Integer(U64), value: 16 }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(7), rhs: Relative(11) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(14), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(14), rhs: Relative(7) }, JumpIf { condition: Relative(18), location: 608 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(17) }, Load { destination: Relative(14), source_pointer: Relative(15) }, Cast { destination: Relative(15), source: Relative(14), bit_size: Integer(U64) }, Const { destination: Relative(14), bit_size: Integer(U64), value: 8 }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(7), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(7), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 617 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(7), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(7), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(7) }, JumpIf { condition: Relative(17), location: 624 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(9), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(4) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(5) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 637 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(6) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 646 }, Call { location: 1204 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 655 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 664 }, Call { location: 1204 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 14 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(9), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 673 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 15 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(9), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(17), location: 682 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32836) }, Load { destination: Relative(9), source_pointer: Relative(15) }, Cast { destination: Relative(15), source: Relative(9), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 689 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(17) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(4) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 18 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(5) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 703 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 19 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 712 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 721 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 21 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 730 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 22 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(11) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 739 }, Call { location: 1204 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 23 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(15), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Shl, bit_size: U64, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U64, lhs: Relative(13), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 748 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 24 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(17), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(17), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(17) }, JumpIf { condition: Relative(18), location: 756 }, Call { location: 1204 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 25 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, Load { destination: Relative(15), source_pointer: Relative(18) }, Cast { destination: Relative(13), source: Relative(15), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(15), op: Shl, bit_size: U64, lhs: Relative(13), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 26 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(18) }, Cast { destination: Relative(4), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(15), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 770 }, Call { location: 1204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 27 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(5), source: Relative(13), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(13), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(13) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 779 }, Call { location: 1204 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(13) }, Cast { destination: Relative(4), source: Relative(6), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(10) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U64, lhs: Relative(5), rhs: Relative(4) }, JumpIf { condition: Relative(10), location: 788 }, Call { location: 1204 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, Load { destination: Relative(6), source_pointer: Relative(10) }, Cast { destination: Relative(5), source: Relative(6), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(6), op: Shl, bit_size: U64, lhs: Relative(5), rhs: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 797 }, Call { location: 1204 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Cast { destination: Relative(4), source: Relative(5), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(4), rhs: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 806 }, Call { location: 1204 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Cast { destination: Relative(2), source: Relative(5), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(5), op: Shl, bit_size: U64, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U64, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U64, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 815 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U64, lhs: Relative(2), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U64, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 822 }, Call { location: 1204 }, Mov { destination: Relative(2), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(2), source: Relative(3) }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(10), source: Relative(6) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(19) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(16) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 33 }, Mov { destination: Relative(1), source: Direct(32838) }, Jump { location: 898 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, JumpIf { condition: Relative(10), location: 920 }, Jump { location: 901 }, Load { destination: Relative(1), source_pointer: Relative(2) }, Cast { destination: Relative(2), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(2), rhs: Relative(1) }, Cast { destination: Relative(2), source: Relative(9), bit_size: Field }, BinaryFieldOp { destination: Relative(5), op: Add, lhs: Relative(3), rhs: Relative(2) }, Cast { destination: Relative(2), source: Relative(17), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(2), rhs: Relative(1) }, Cast { destination: Relative(1), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(2), op: Add, lhs: Relative(3), rhs: Relative(1) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Return, Load { destination: Relative(10), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(11), op: Mul, lhs: Relative(10), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Sub, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 926 }, Call { location: 1232 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 929 }, Call { location: 1207 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Field }, BinaryFieldOp { destination: Relative(13), op: Mul, lhs: Relative(11), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(14), op: Mul, lhs: Relative(10), rhs: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Sub, lhs: Relative(3), rhs: Relative(10) }, BinaryFieldOp { destination: Relative(10), op: Mul, lhs: Relative(13), rhs: Relative(11) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(14), rhs: Relative(10) }, Store { destination_pointer: Relative(2), source: Relative(11) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 898 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, Load { destination: Relative(20), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32839) }, JumpIf { condition: Relative(21), location: 947 }, Call { location: 1207 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(14) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Const { destination: Relative(20), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 16 }, BlackBox(ToRadix { input: Relative(21), radix: Relative(4), output_pointer: Relative(22), num_limbs: Relative(23), output_bits: Relative(20) }), BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(20) }, BinaryIntOp { destination: Relative(22), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(21) }, JumpIf { condition: Relative(22), location: 963 }, Call { location: 1204 }, Mov { destination: Relative(10), source: Relative(18) }, Jump { location: 965 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Direct(32836) }, JumpIf { condition: Relative(20), location: 971 }, Jump { location: 968 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(10) }, BinaryIntOp { destination: Relative(22), op: LessThanEquals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 975 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(10) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Load { destination: Relative(23), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 982 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 1210 }, Mov { destination: Relative(24), source: Direct(32773) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(20) }, Store { destination_pointer: Relative(26), source: Relative(22) }, Store { destination_pointer: Relative(3), source: Relative(24) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(32838) }, Mov { destination: Relative(10), source: Relative(20) }, Jump { location: 965 }, Load { destination: Relative(10), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, Load { destination: Relative(14), source_pointer: Relative(21) }, Const { destination: Relative(20), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 32 }, BlackBox(ToRadix { input: Relative(14), radix: Relative(4), output_pointer: Relative(21), num_limbs: Relative(22), output_bits: Relative(20) }), BinaryIntOp { destination: Relative(14), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(6), source: Relative(18) }, Jump { location: 1008 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(20), location: 1014 }, Jump { location: 1011 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 540 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(6) }, BinaryIntOp { destination: Relative(21), op: LessThanEquals, bit_size: U32, lhs: Relative(14), rhs: Relative(20) }, JumpIf { condition: Relative(21), location: 1018 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(6) }, Load { destination: Relative(21), source_pointer: Relative(23) }, Load { destination: Relative(22), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(20), rhs: Relative(5) }, JumpIf { condition: Relative(23), location: 1025 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5345 }, Call { location: 1210 }, Mov { destination: Relative(23), source: Direct(32773) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(20) }, Store { destination_pointer: Relative(25), source: Relative(21) }, Store { destination_pointer: Relative(3), source: Relative(23) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32838) }, Mov { destination: Relative(6), source: Relative(20) }, Jump { location: 1008 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(1) }, Load { destination: Relative(15), source_pointer: Relative(20) }, Cast { destination: Relative(20), source: Relative(15), bit_size: Integer(U128) }, Cast { destination: Relative(17), source: Relative(20), bit_size: Field }, BinaryFieldOp { destination: Relative(20), op: Sub, lhs: Relative(15), rhs: Relative(17) }, BinaryFieldOp { destination: Relative(22), op: Mul, lhs: Relative(20), rhs: Relative(12) }, BinaryFieldOp { destination: Relative(20), op: Mul, lhs: Direct(32842), rhs: Relative(22) }, BinaryFieldOp { destination: Relative(23), op: Add, lhs: Relative(17), rhs: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(15), rhs: Relative(23) }, JumpIf { condition: Relative(20), location: 1049 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(15), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(23), source: Direct(32773) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(20) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 7 }, Call { location: 1210 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(15) }, Store { destination_pointer: Relative(24), source: Relative(22) }, Store { destination_pointer: Relative(13), source: Relative(17) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(15) }, Load { destination: Relative(17), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(23) }, Load { destination: Relative(24), source_pointer: Relative(26) }, Load { destination: Relative(23), source_pointer: Relative(14) }, Mov { destination: Direct(32771), source: Relative(23) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(25), source: Direct(32773) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(15) }, Store { destination_pointer: Relative(27), source: Relative(17) }, Mov { destination: Direct(32771), source: Relative(25) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(20) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(32838) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 10 }, Call { location: 1210 }, Mov { destination: Relative(20), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(17) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Store { destination_pointer: Relative(14), source: Relative(20) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(15) }, Jump { location: 347 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1112 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 1120 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 1131 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Load { destination: Relative(8), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(13), location: 1138 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 219 }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(13), location: 1154 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(14) }, Load { destination: Relative(13), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32839) }, JumpIf { condition: Relative(14), location: 1161 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, Store { destination_pointer: Relative(16), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 207 }, Load { destination: Relative(12), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(8) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 1177 }, Call { location: 1204 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(8) }, Load { destination: Relative(12), source_pointer: Relative(15) }, Load { destination: Relative(14), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32839) }, JumpIf { condition: Relative(15), location: 1184 }, Call { location: 1207 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 170 }, Call { location: 1210 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Store { destination_pointer: Relative(17), source: Relative(12) }, Store { destination_pointer: Relative(11), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32838) }, Mov { destination: Relative(8), source: Relative(12) }, Jump { location: 196 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 1200 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 1214 }, Jump { location: 1216 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 1231 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 1228 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 1221 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 1231 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], "debug_symbols": "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", "file_map": { diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_underflow/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_underflow/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 38d74d64d01..39d99ee84cd 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_underflow/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_underflow/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -45,9 +45,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 47 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 10 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 19 }, Jump { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 255 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 24 }, Call { location: 53 }, Jump { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 29 }, Jump { location: 36 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 3 }, BinaryIntOp { destination: Relative(3), op: Mul, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U8, lhs: Relative(3), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 35 }, Call { location: 56 }, Jump { location: 36 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 7 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 40 }, Jump { location: 46 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U8, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 45 }, Call { location: 59 }, Jump { location: 46 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 52 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 53 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 10 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 19 }, Jump { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 255 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 24 }, Call { location: 59 }, Jump { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 9 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 7 }, JumpIf { condition: Relative(3), location: 30 }, Jump { location: 32 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, Jump { location: 32 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 36 }, Jump { location: 43 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 3 }, BinaryIntOp { destination: Relative(4), op: Mul, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Div, bit_size: U8, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 42 }, Call { location: 62 }, Jump { location: 43 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 46 }, Jump { location: 52 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U8, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 51 }, Call { location: 65 }, Jump { location: 52 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 58 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "nZJNioQwEEbvUussrMSf0as0IlFjEwhR0jowiHef0upM24uBxk2esfIqFfhW6E273Bvrh/EB1W2FNljn7L1xY6dnO3r6u0KyL5hBhQIwZ5RQSQEyYSBDMhSDBEXIGSSkAlTCQIZkKEbKICEjFAdSEnICMiRDMUjIt01AnLaZgzH7sKfx6VGTDsbPUPnFOQHf2i3Hocek/cFZB6omAozvidRwsM7sX5t42cn/aqmeLiYvO/tYR8To49cVv/jzi/KKX8a3Y5ld8CVGX2J+xZdF9JV882va6c6Gtzxue6dgdevMczssvjtV558pVmKepzB2pl+C2TudQk3rLS1EJmvKNGXslpUix3rbr/4F", + "debug_symbols": "nZPRqoQgEED/xWcfGl0z+5UlwsoWQSzcunCJ/v1Oubbtw4WlF082HmcGnIV0ppkftfX98CTlfSFNsM7ZR+2GVk928Ph3Idm2gCAlUAJ5hCIlo4RlERDBIngEChyR7+B48obAIwLBIzCWI2REEaF23LIIiEBBIlAoEDKiiFA7BArFulKSaq+nYMxW+qkZbHHUwfiJlH52jpIf7eb90HPUfuekA0YzSozvkHhhb53Zvlb6trP/VcVfLmRvW3ytA0Dyobji8yM/V1d8kXoHkV/x5VG/vJRfHfmVuOAzSD6DK/UzJpPP2Ydf4U63NnxMx7rdFKxunHlt+9m3p+j0O6ZImq4xDK3p5mC2m04jhutdcCqKCicMH/49FzSX1bql/gM=", "file_map": { "50": { "source": "// Regression test for https://github.com/noir-lang/noir/issues/3493\nfn main(x: u8) {\n if x == 10 {\n x + 255;\n }\n if x == 9 {\n x << 7;\n }\n if x == 128 {\n x * 3;\n }\n if x == 7 {\n x - 8;\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_underflow/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_underflow/execute__tests__force_brillig_true_inliner_0.snap index 38d74d64d01..39d99ee84cd 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_underflow/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_underflow/execute__tests__force_brillig_true_inliner_0.snap @@ -45,9 +45,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 47 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 10 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 19 }, Jump { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 255 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 24 }, Call { location: 53 }, Jump { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 29 }, Jump { location: 36 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 3 }, BinaryIntOp { destination: Relative(3), op: Mul, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U8, lhs: Relative(3), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 35 }, Call { location: 56 }, Jump { location: 36 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 7 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 40 }, Jump { location: 46 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U8, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 45 }, Call { location: 59 }, Jump { location: 46 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 52 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 53 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 10 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 19 }, Jump { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 255 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 24 }, Call { location: 59 }, Jump { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 9 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 7 }, JumpIf { condition: Relative(3), location: 30 }, Jump { location: 32 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, Jump { location: 32 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 36 }, Jump { location: 43 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 3 }, BinaryIntOp { destination: Relative(4), op: Mul, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Div, bit_size: U8, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 42 }, Call { location: 62 }, Jump { location: 43 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 46 }, Jump { location: 52 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U8, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 51 }, Call { location: 65 }, Jump { location: 52 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 58 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "nZJNioQwEEbvUussrMSf0as0IlFjEwhR0jowiHef0upM24uBxk2esfIqFfhW6E273Bvrh/EB1W2FNljn7L1xY6dnO3r6u0KyL5hBhQIwZ5RQSQEyYSBDMhSDBEXIGSSkAlTCQIZkKEbKICEjFAdSEnICMiRDMUjIt01AnLaZgzH7sKfx6VGTDsbPUPnFOQHf2i3Hocek/cFZB6omAozvidRwsM7sX5t42cn/aqmeLiYvO/tYR8To49cVv/jzi/KKX8a3Y5ld8CVGX2J+xZdF9JV882va6c6Gtzxue6dgdevMczssvjtV558pVmKepzB2pl+C2TudQk3rLS1EJmvKNGXslpUix3rbr/4F", + "debug_symbols": "nZPRqoQgEED/xWcfGl0z+5UlwsoWQSzcunCJ/v1Oubbtw4WlF082HmcGnIV0ppkftfX98CTlfSFNsM7ZR+2GVk928Ph3Idm2gCAlUAJ5hCIlo4RlERDBIngEChyR7+B48obAIwLBIzCWI2REEaF23LIIiEBBIlAoEDKiiFA7BArFulKSaq+nYMxW+qkZbHHUwfiJlH52jpIf7eb90HPUfuekA0YzSozvkHhhb53Zvlb6trP/VcVfLmRvW3ytA0Dyobji8yM/V1d8kXoHkV/x5VG/vJRfHfmVuOAzSD6DK/UzJpPP2Ydf4U63NnxMx7rdFKxunHlt+9m3p+j0O6ZImq4xDK3p5mC2m04jhutdcCqKCicMH/49FzSX1bql/gM=", "file_map": { "50": { "source": "// Regression test for https://github.com/noir-lang/noir/issues/3493\nfn main(x: u8) {\n if x == 10 {\n x + 255;\n }\n if x == 9 {\n x << 7;\n }\n if x == 128 {\n x * 3;\n }\n if x == 7 {\n x - 8;\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_underflow/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_underflow/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 38d74d64d01..39d99ee84cd 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_underflow/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_underflow/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -45,9 +45,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 47 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 10 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 19 }, Jump { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 255 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 24 }, Call { location: 53 }, Jump { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 29 }, Jump { location: 36 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 3 }, BinaryIntOp { destination: Relative(3), op: Mul, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U8, lhs: Relative(3), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 35 }, Call { location: 56 }, Jump { location: 36 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 7 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 40 }, Jump { location: 46 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U8, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 45 }, Call { location: 59 }, Jump { location: 46 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 52 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 53 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 10 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 19 }, Jump { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 255 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 24 }, Call { location: 59 }, Jump { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 9 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 7 }, JumpIf { condition: Relative(3), location: 30 }, Jump { location: 32 }, BinaryIntOp { destination: Relative(3), op: Shl, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, Jump { location: 32 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 36 }, Jump { location: 43 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 3 }, BinaryIntOp { destination: Relative(4), op: Mul, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Div, bit_size: U8, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 42 }, Call { location: 62 }, Jump { location: 43 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 46 }, Jump { location: 52 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U8, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U8, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 51 }, Call { location: 65 }, Jump { location: 52 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 58 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "nZJNioQwEEbvUussrMSf0as0IlFjEwhR0jowiHef0upM24uBxk2esfIqFfhW6E273Bvrh/EB1W2FNljn7L1xY6dnO3r6u0KyL5hBhQIwZ5RQSQEyYSBDMhSDBEXIGSSkAlTCQIZkKEbKICEjFAdSEnICMiRDMUjIt01AnLaZgzH7sKfx6VGTDsbPUPnFOQHf2i3Hocek/cFZB6omAozvidRwsM7sX5t42cn/aqmeLiYvO/tYR8To49cVv/jzi/KKX8a3Y5ld8CVGX2J+xZdF9JV882va6c6Gtzxue6dgdevMczssvjtV558pVmKepzB2pl+C2TudQk3rLS1EJmvKNGXslpUix3rbr/4F", + "debug_symbols": "nZPRqoQgEED/xWcfGl0z+5UlwsoWQSzcunCJ/v1Oubbtw4WlF082HmcGnIV0ppkftfX98CTlfSFNsM7ZR+2GVk928Ph3Idm2gCAlUAJ5hCIlo4RlERDBIngEChyR7+B48obAIwLBIzCWI2REEaF23LIIiEBBIlAoEDKiiFA7BArFulKSaq+nYMxW+qkZbHHUwfiJlH52jpIf7eb90HPUfuekA0YzSozvkHhhb53Zvlb6trP/VcVfLmRvW3ytA0Dyobji8yM/V1d8kXoHkV/x5VG/vJRfHfmVuOAzSD6DK/UzJpPP2Ydf4U63NnxMx7rdFKxunHlt+9m3p+j0O6ZImq4xDK3p5mC2m04jhutdcCqKCicMH/49FzSX1bql/gM=", "file_map": { "50": { "source": "// Regression test for https://github.com/noir-lang/noir/issues/3493\nfn main(x: u8) {\n if x == 10 {\n x + 255;\n }\n if x == 9 {\n x << 7;\n }\n if x == 128 {\n x * 3;\n }\n if x == 7 {\n x - 8;\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__expanded.snap new file mode 100644 index 00000000000..4461477310c --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__expanded.snap @@ -0,0 +1,11 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: expanded_code +--- +fn main(active: bool, a: pub i16) -> pub i16 { + if active { + a >> a + } else { + 0_i16 + } +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..180ed8721e3 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -0,0 +1,171 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "active", + "type": { + "kind": "boolean" + }, + "visibility": "private" + }, + { + "name": "a", + "type": { + "kind": "integer", + "sign": "signed", + "width": 16 + }, + "visibility": "public" + } + ], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "signed", + "width": 16 + }, + "visibility": "public" + }, + "error_types": { + "14514982005979867414": { + "error_kind": "string", + "string": "attempt to bit-shift with overflow" + }, + "16061458491050355795": { + "error_kind": "string", + "string": "Field failed to decompose into specified 5 limbs" + } + } + }, + "bytecode": [ + "func 0", + "current witness index : _75", + "private parameters indices : [_0]", + "public parameters indices : [_1]", + "return value indices : [_2]", + "BLACKBOX::RANGE [(_0, 1)] []", + "BLACKBOX::RANGE [(_1, 16)] []", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 65521 ], EXPR [ 65536 ]], outputs: [_3, _4]", + "BLACKBOX::RANGE [(_3, 1)] []", + "BLACKBOX::RANGE [(_4, 16)] []", + "EXPR [ (1, _1) (-65536, _3) (-1, _4) 65521 ]", + "EXPR [ (-1, _0, _3) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 0 ], EXPR [ 32768 ]], outputs: [_5, _6]", + "BLACKBOX::RANGE [(_5, 1)] []", + "BLACKBOX::RANGE [(_6, 15)] []", + "EXPR [ (1, _1) (-32768, _5) (-1, _6) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 131056 ], EXPR [ 131072 ]], outputs: [_7, _8]", + "BLACKBOX::RANGE [(_7, 1)] []", + "BLACKBOX::RANGE [(_8, 17)] []", + "EXPR [ (1, _1) (-131072, _7) (-1, _8) 131056 ]", + "EXPR [ (2, _5, _7) (-1, _5) (-1, _7) (-1, _9) 1 ]", + "EXPR [ (1, _1, _9) (-1, _10) 0 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _10, _0) 0 ], EXPR [ 5 ], EXPR [ 2 ]], outputs: [[_11, _12, _13, _14, _15]]", + "BLACKBOX::RANGE [(_11, 1)] []", + "BLACKBOX::RANGE [(_12, 1)] []", + "BLACKBOX::RANGE [(_13, 1)] []", + "BLACKBOX::RANGE [(_14, 1)] []", + "BLACKBOX::RANGE [(_15, 1)] []", + "EXPR [ (1, _0, _10) (-1, _11) (-2, _12) (-4, _13) (-8, _14) (-16, _15) 0 ]", + "EXPR [ (1, _15, _15) (2, _15) (-1, _16) 1 ]", + "EXPR [ (-1, _14) (-1, _17) 1 ]", + "EXPR [ (2, _14, _16) (1, _16, _17) (-1, _18) 0 ]", + "EXPR [ (1, _18, _18) (-1, _19) 0 ]", + "EXPR [ (-1, _13) (-1, _20) 1 ]", + "EXPR [ (2, _13, _19) (1, _19, _20) (-1, _21) 0 ]", + "EXPR [ (1, _21, _21) (-1, _22) 0 ]", + "EXPR [ (-1, _12) (-1, _23) 1 ]", + "EXPR [ (2, _12, _22) (1, _22, _23) (-1, _24) 0 ]", + "EXPR [ (1, _24, _24) (-1, _25) 0 ]", + "EXPR [ (-1, _11) (-1, _26) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 0 ], EXPR [ 32768 ]], outputs: [_27, _28]", + "BLACKBOX::RANGE [(_27, 1)] []", + "BLACKBOX::RANGE [(_28, 15)] []", + "EXPR [ (1, _1) (-32768, _27) (-1, _28) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 131072 ], EXPR [ 131072 ]], outputs: [_29, _30]", + "BLACKBOX::RANGE [(_29, 1)] []", + "BLACKBOX::RANGE [(_30, 17)] []", + "EXPR [ (1, _1) (-131072, _29) (-1, _30) 131072 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _29, _27) (1, _1) (-1, _27) (-1, _29) 1 ], EXPR [ 65536 ]], outputs: [_31, _32]", + "BLACKBOX::RANGE [(_31, 1)] []", + "BLACKBOX::RANGE [(_32, 16)] []", + "EXPR [ (2, _27, _29) (1, _1) (-1, _27) (-1, _29) (-65536, _31) (-1, _32) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _25, _11) (1, _25, _26) 0 ], EXPR [ 32768 ]], outputs: [_33, _34]", + "BLACKBOX::RANGE [(_33, 1)] []", + "BLACKBOX::RANGE [(_34, 15)] []", + "EXPR [ (2, _11, _25) (-1, _73) 0 ]", + "EXPR [ (1, _25, _26) (-1, _74) 0 ]", + "EXPR [ (-32768, _33) (-1, _34) (1, _73) (1, _74) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _32) 0 ], EXPR [ 32768 ]], outputs: [_35, _36]", + "BLACKBOX::RANGE [(_35, 1)] []", + "BLACKBOX::RANGE [(_36, 15)] []", + "EXPR [ (1, _32) (-32768, _35) (-1, _36) 0 ]", + "EXPR [ (-1, _37) (-1, _73) (-1, _74) 32768 ]", + "EXPR [ (2, _33, _37) (-1, _75) 0 ]", + "EXPR [ (-1, _38) (1, _73) (1, _74) (1, _75) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _38) 0 ]], outputs: [_39]", + "EXPR [ (1, _38, _39) (1, _40) -1 ]", + "EXPR [ (1, _38, _40) 0 ]", + "EXPR [ (1, _0, _40) 0 ]", + "BRILLIG CALL func 0: PREDICATE: EXPR [ (1, _0) 0 ]", + "inputs: [EXPR [ (-2, _32, _35) (1, _32) (65536, _35) 0 ], EXPR [ (2, _25, _11) (1, _25, _26) (2, _37, _33) 0 ]], outputs: [_41, _42]", + "BLACKBOX::RANGE [(_41, 16)] []", + "BLACKBOX::RANGE [(_42, 16)] []", + "EXPR [ (-1, _0) (-1, _42) (-1, _43) (1, _73) (1, _74) (1, _75) 0 ]", + "BLACKBOX::RANGE [(_43, 16)] []", + "EXPR [ (-1, _44) (1, _73) (1, _74) (1, _75) 0 ]", + "EXPR [ (1, _41, _44) (1, _42) (-1, _45) 0 ]", + "EXPR [ (-2, _32, _35) (1, _32) (65536, _35) (-1, _46) 0 ]", + "EXPR [ (-1, _0, _45) (1, _0, _46) 0 ]", + "EXPR [ (-1, _41) (-1, _47) 32768 ]", + "EXPR [ (-2, _33, _35) (1, _33) (1, _35) (-1, _48) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _41) 0 ]], outputs: [_49]", + "EXPR [ (1, _41, _49) (1, _50) -1 ]", + "EXPR [ (1, _41, _50) 0 ]", + "EXPR [ (2, _47, _48) (1, _41) (-1, _51) 0 ]", + "EXPR [ (-1, _50) (-1, _52) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _42) 0 ]], outputs: [_53]", + "EXPR [ (1, _42, _53) (1, _54) -1 ]", + "EXPR [ (1, _42, _54) 0 ]", + "EXPR [ (-2, _35, _42) (65536, _35) (1, _42) (-1, _55) 0 ]", + "EXPR [ (-1, _54) (-1, _56) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _29, _27) (1, _51, _52) (1, _27) (1, _29) 131071 ], EXPR [ 65536 ]], outputs: [_57, _58]", + "BLACKBOX::RANGE [(_57, 2)] []", + "BLACKBOX::RANGE [(_58, 16)] []", + "EXPR [ (-2, _27, _29) (1, _51, _52) (1, _27) (1, _29) (-65536, _57) (-1, _58) 131071 ]", + "EXPR [ (131070, _27, _29) (-65535, _27) (-65535, _29) (-1, _59) 65535 ]", + "EXPR [ (-1, _9) (-1, _60) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _9, _58) (1, _59, _60) 0 ], EXPR [ 65536 ]], outputs: [_61, _62]", + "BLACKBOX::RANGE [(_61, 1)] []", + "BLACKBOX::RANGE [(_62, 16)] []", + "EXPR [ (1, _9, _58) (1, _59, _60) (-65536, _61) (-1, _62) 0 ]", + "EXPR [ (-1, _0, _62) (1, _2) 0 ]", + "unconstrained func 0", + "[Const { destination: Direct(10), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(11), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(10), offset_address: Direct(11) }, BinaryFieldOp { destination: Direct(2), op: IntegerDiv, lhs: Direct(0), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Mul, lhs: Direct(2), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Sub, lhs: Direct(0), rhs: Direct(1) }, Mov { destination: Direct(0), source: Direct(2) }, Stop { return_data: HeapVector { pointer: Direct(11), size: Direct(10) } }]", + "unconstrained func 1", + "[Const { destination: Direct(5), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(6), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(7), bit_size: Integer(U32), value: 3 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(7), offset_address: Direct(5) }, Cast { destination: Direct(1), source: Direct(1), bit_size: Integer(U32) }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(7), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(3), op: IntegerDiv, lhs: Direct(0), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Mul, lhs: Direct(3), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Sub, lhs: Direct(0), rhs: Direct(4) }, Store { destination_pointer: Direct(9), source: Direct(4) }, BinaryIntOp { destination: Direct(9), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(6) }, Mov { destination: Direct(0), source: Direct(3) }, BinaryIntOp { destination: Direct(8), op: LessThan, bit_size: U32, lhs: Direct(9), rhs: Direct(7) }, JumpIf { condition: Direct(8), location: 7 }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, Stop { return_data: HeapVector { pointer: Direct(9), size: Direct(1) } }]", + "unconstrained func 2", + "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" + ], + "debug_symbols": "ddNLboMwEIDhu3jNIn6bXKWqIkKcCgkBcqBSFeXuNf6dNl10M8Ye5hPY47u4xPP2cRqm63wTx7e7OKdhHIeP0zj33TrMU169PxrxnJ7WFGNeEi/5XLV0KU6rOE7bODbisxu38tJt6aYyrl3K2UMj4nTJYwavwxj3p0fzW334v9SrWuvDT7HN1e951vVD+vO9QomjbIQu0ZRoS3Ql+hJDiW2J8sAgGSiX1EsAiSAhJIYEkSgKRaEoFIWiUBSKQlEoCkWhaBSNouuvoGgUjaJRNIpG0SgGxaAYFFN3BMWgGBSDYlAMikWxKBbFoti6sSgWxaJYFIviUByKQ3EoDsXV80FxKA7FoXgUj+JRPIpH8Si+HjOKR/EoASWgBJSAElACSkAJtVtQAkqL0qK0KC1KuyuPvZPT0J3HWC/QdZv6l/u0fi3PzPPGLWnu42VLce/lksvd/Q0=", + "file_map": { + "50": { + "source": "fn main(active: bool, a: pub i16) -> pub i16 {\n if active {\n (a >> a)\n } else {\n 0\n }\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "directive_integer_quotient", + "directive_to_radix", + "directive_invert" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_false_inliner_0.snap new file mode 100644 index 00000000000..180ed8721e3 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_false_inliner_0.snap @@ -0,0 +1,171 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "active", + "type": { + "kind": "boolean" + }, + "visibility": "private" + }, + { + "name": "a", + "type": { + "kind": "integer", + "sign": "signed", + "width": 16 + }, + "visibility": "public" + } + ], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "signed", + "width": 16 + }, + "visibility": "public" + }, + "error_types": { + "14514982005979867414": { + "error_kind": "string", + "string": "attempt to bit-shift with overflow" + }, + "16061458491050355795": { + "error_kind": "string", + "string": "Field failed to decompose into specified 5 limbs" + } + } + }, + "bytecode": [ + "func 0", + "current witness index : _75", + "private parameters indices : [_0]", + "public parameters indices : [_1]", + "return value indices : [_2]", + "BLACKBOX::RANGE [(_0, 1)] []", + "BLACKBOX::RANGE [(_1, 16)] []", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 65521 ], EXPR [ 65536 ]], outputs: [_3, _4]", + "BLACKBOX::RANGE [(_3, 1)] []", + "BLACKBOX::RANGE [(_4, 16)] []", + "EXPR [ (1, _1) (-65536, _3) (-1, _4) 65521 ]", + "EXPR [ (-1, _0, _3) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 0 ], EXPR [ 32768 ]], outputs: [_5, _6]", + "BLACKBOX::RANGE [(_5, 1)] []", + "BLACKBOX::RANGE [(_6, 15)] []", + "EXPR [ (1, _1) (-32768, _5) (-1, _6) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 131056 ], EXPR [ 131072 ]], outputs: [_7, _8]", + "BLACKBOX::RANGE [(_7, 1)] []", + "BLACKBOX::RANGE [(_8, 17)] []", + "EXPR [ (1, _1) (-131072, _7) (-1, _8) 131056 ]", + "EXPR [ (2, _5, _7) (-1, _5) (-1, _7) (-1, _9) 1 ]", + "EXPR [ (1, _1, _9) (-1, _10) 0 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _10, _0) 0 ], EXPR [ 5 ], EXPR [ 2 ]], outputs: [[_11, _12, _13, _14, _15]]", + "BLACKBOX::RANGE [(_11, 1)] []", + "BLACKBOX::RANGE [(_12, 1)] []", + "BLACKBOX::RANGE [(_13, 1)] []", + "BLACKBOX::RANGE [(_14, 1)] []", + "BLACKBOX::RANGE [(_15, 1)] []", + "EXPR [ (1, _0, _10) (-1, _11) (-2, _12) (-4, _13) (-8, _14) (-16, _15) 0 ]", + "EXPR [ (1, _15, _15) (2, _15) (-1, _16) 1 ]", + "EXPR [ (-1, _14) (-1, _17) 1 ]", + "EXPR [ (2, _14, _16) (1, _16, _17) (-1, _18) 0 ]", + "EXPR [ (1, _18, _18) (-1, _19) 0 ]", + "EXPR [ (-1, _13) (-1, _20) 1 ]", + "EXPR [ (2, _13, _19) (1, _19, _20) (-1, _21) 0 ]", + "EXPR [ (1, _21, _21) (-1, _22) 0 ]", + "EXPR [ (-1, _12) (-1, _23) 1 ]", + "EXPR [ (2, _12, _22) (1, _22, _23) (-1, _24) 0 ]", + "EXPR [ (1, _24, _24) (-1, _25) 0 ]", + "EXPR [ (-1, _11) (-1, _26) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 0 ], EXPR [ 32768 ]], outputs: [_27, _28]", + "BLACKBOX::RANGE [(_27, 1)] []", + "BLACKBOX::RANGE [(_28, 15)] []", + "EXPR [ (1, _1) (-32768, _27) (-1, _28) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 131072 ], EXPR [ 131072 ]], outputs: [_29, _30]", + "BLACKBOX::RANGE [(_29, 1)] []", + "BLACKBOX::RANGE [(_30, 17)] []", + "EXPR [ (1, _1) (-131072, _29) (-1, _30) 131072 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _29, _27) (1, _1) (-1, _27) (-1, _29) 1 ], EXPR [ 65536 ]], outputs: [_31, _32]", + "BLACKBOX::RANGE [(_31, 1)] []", + "BLACKBOX::RANGE [(_32, 16)] []", + "EXPR [ (2, _27, _29) (1, _1) (-1, _27) (-1, _29) (-65536, _31) (-1, _32) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _25, _11) (1, _25, _26) 0 ], EXPR [ 32768 ]], outputs: [_33, _34]", + "BLACKBOX::RANGE [(_33, 1)] []", + "BLACKBOX::RANGE [(_34, 15)] []", + "EXPR [ (2, _11, _25) (-1, _73) 0 ]", + "EXPR [ (1, _25, _26) (-1, _74) 0 ]", + "EXPR [ (-32768, _33) (-1, _34) (1, _73) (1, _74) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _32) 0 ], EXPR [ 32768 ]], outputs: [_35, _36]", + "BLACKBOX::RANGE [(_35, 1)] []", + "BLACKBOX::RANGE [(_36, 15)] []", + "EXPR [ (1, _32) (-32768, _35) (-1, _36) 0 ]", + "EXPR [ (-1, _37) (-1, _73) (-1, _74) 32768 ]", + "EXPR [ (2, _33, _37) (-1, _75) 0 ]", + "EXPR [ (-1, _38) (1, _73) (1, _74) (1, _75) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _38) 0 ]], outputs: [_39]", + "EXPR [ (1, _38, _39) (1, _40) -1 ]", + "EXPR [ (1, _38, _40) 0 ]", + "EXPR [ (1, _0, _40) 0 ]", + "BRILLIG CALL func 0: PREDICATE: EXPR [ (1, _0) 0 ]", + "inputs: [EXPR [ (-2, _32, _35) (1, _32) (65536, _35) 0 ], EXPR [ (2, _25, _11) (1, _25, _26) (2, _37, _33) 0 ]], outputs: [_41, _42]", + "BLACKBOX::RANGE [(_41, 16)] []", + "BLACKBOX::RANGE [(_42, 16)] []", + "EXPR [ (-1, _0) (-1, _42) (-1, _43) (1, _73) (1, _74) (1, _75) 0 ]", + "BLACKBOX::RANGE [(_43, 16)] []", + "EXPR [ (-1, _44) (1, _73) (1, _74) (1, _75) 0 ]", + "EXPR [ (1, _41, _44) (1, _42) (-1, _45) 0 ]", + "EXPR [ (-2, _32, _35) (1, _32) (65536, _35) (-1, _46) 0 ]", + "EXPR [ (-1, _0, _45) (1, _0, _46) 0 ]", + "EXPR [ (-1, _41) (-1, _47) 32768 ]", + "EXPR [ (-2, _33, _35) (1, _33) (1, _35) (-1, _48) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _41) 0 ]], outputs: [_49]", + "EXPR [ (1, _41, _49) (1, _50) -1 ]", + "EXPR [ (1, _41, _50) 0 ]", + "EXPR [ (2, _47, _48) (1, _41) (-1, _51) 0 ]", + "EXPR [ (-1, _50) (-1, _52) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _42) 0 ]], outputs: [_53]", + "EXPR [ (1, _42, _53) (1, _54) -1 ]", + "EXPR [ (1, _42, _54) 0 ]", + "EXPR [ (-2, _35, _42) (65536, _35) (1, _42) (-1, _55) 0 ]", + "EXPR [ (-1, _54) (-1, _56) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _29, _27) (1, _51, _52) (1, _27) (1, _29) 131071 ], EXPR [ 65536 ]], outputs: [_57, _58]", + "BLACKBOX::RANGE [(_57, 2)] []", + "BLACKBOX::RANGE [(_58, 16)] []", + "EXPR [ (-2, _27, _29) (1, _51, _52) (1, _27) (1, _29) (-65536, _57) (-1, _58) 131071 ]", + "EXPR [ (131070, _27, _29) (-65535, _27) (-65535, _29) (-1, _59) 65535 ]", + "EXPR [ (-1, _9) (-1, _60) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _9, _58) (1, _59, _60) 0 ], EXPR [ 65536 ]], outputs: [_61, _62]", + "BLACKBOX::RANGE [(_61, 1)] []", + "BLACKBOX::RANGE [(_62, 16)] []", + "EXPR [ (1, _9, _58) (1, _59, _60) (-65536, _61) (-1, _62) 0 ]", + "EXPR [ (-1, _0, _62) (1, _2) 0 ]", + "unconstrained func 0", + "[Const { destination: Direct(10), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(11), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(10), offset_address: Direct(11) }, BinaryFieldOp { destination: Direct(2), op: IntegerDiv, lhs: Direct(0), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Mul, lhs: Direct(2), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Sub, lhs: Direct(0), rhs: Direct(1) }, Mov { destination: Direct(0), source: Direct(2) }, Stop { return_data: HeapVector { pointer: Direct(11), size: Direct(10) } }]", + "unconstrained func 1", + "[Const { destination: Direct(5), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(6), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(7), bit_size: Integer(U32), value: 3 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(7), offset_address: Direct(5) }, Cast { destination: Direct(1), source: Direct(1), bit_size: Integer(U32) }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(7), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(3), op: IntegerDiv, lhs: Direct(0), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Mul, lhs: Direct(3), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Sub, lhs: Direct(0), rhs: Direct(4) }, Store { destination_pointer: Direct(9), source: Direct(4) }, BinaryIntOp { destination: Direct(9), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(6) }, Mov { destination: Direct(0), source: Direct(3) }, BinaryIntOp { destination: Direct(8), op: LessThan, bit_size: U32, lhs: Direct(9), rhs: Direct(7) }, JumpIf { condition: Direct(8), location: 7 }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, Stop { return_data: HeapVector { pointer: Direct(9), size: Direct(1) } }]", + "unconstrained func 2", + "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" + ], + "debug_symbols": "ddNLboMwEIDhu3jNIn6bXKWqIkKcCgkBcqBSFeXuNf6dNl10M8Ye5hPY47u4xPP2cRqm63wTx7e7OKdhHIeP0zj33TrMU169PxrxnJ7WFGNeEi/5XLV0KU6rOE7bODbisxu38tJt6aYyrl3K2UMj4nTJYwavwxj3p0fzW334v9SrWuvDT7HN1e951vVD+vO9QomjbIQu0ZRoS3Ql+hJDiW2J8sAgGSiX1EsAiSAhJIYEkSgKRaEoFIWiUBSKQlEoCkWhaBSNouuvoGgUjaJRNIpG0SgGxaAYFFN3BMWgGBSDYlAMikWxKBbFoti6sSgWxaJYFIviUByKQ3EoDsXV80FxKA7FoXgUj+JRPIpH8Si+HjOKR/EoASWgBJSAElACSkAJtVtQAkqL0qK0KC1KuyuPvZPT0J3HWC/QdZv6l/u0fi3PzPPGLWnu42VLce/lksvd/Q0=", + "file_map": { + "50": { + "source": "fn main(active: bool, a: pub i16) -> pub i16 {\n if active {\n (a >> a)\n } else {\n 0\n }\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "directive_integer_quotient", + "directive_to_radix", + "directive_invert" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_false_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..180ed8721e3 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -0,0 +1,171 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "active", + "type": { + "kind": "boolean" + }, + "visibility": "private" + }, + { + "name": "a", + "type": { + "kind": "integer", + "sign": "signed", + "width": 16 + }, + "visibility": "public" + } + ], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "signed", + "width": 16 + }, + "visibility": "public" + }, + "error_types": { + "14514982005979867414": { + "error_kind": "string", + "string": "attempt to bit-shift with overflow" + }, + "16061458491050355795": { + "error_kind": "string", + "string": "Field failed to decompose into specified 5 limbs" + } + } + }, + "bytecode": [ + "func 0", + "current witness index : _75", + "private parameters indices : [_0]", + "public parameters indices : [_1]", + "return value indices : [_2]", + "BLACKBOX::RANGE [(_0, 1)] []", + "BLACKBOX::RANGE [(_1, 16)] []", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 65521 ], EXPR [ 65536 ]], outputs: [_3, _4]", + "BLACKBOX::RANGE [(_3, 1)] []", + "BLACKBOX::RANGE [(_4, 16)] []", + "EXPR [ (1, _1) (-65536, _3) (-1, _4) 65521 ]", + "EXPR [ (-1, _0, _3) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 0 ], EXPR [ 32768 ]], outputs: [_5, _6]", + "BLACKBOX::RANGE [(_5, 1)] []", + "BLACKBOX::RANGE [(_6, 15)] []", + "EXPR [ (1, _1) (-32768, _5) (-1, _6) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 131056 ], EXPR [ 131072 ]], outputs: [_7, _8]", + "BLACKBOX::RANGE [(_7, 1)] []", + "BLACKBOX::RANGE [(_8, 17)] []", + "EXPR [ (1, _1) (-131072, _7) (-1, _8) 131056 ]", + "EXPR [ (2, _5, _7) (-1, _5) (-1, _7) (-1, _9) 1 ]", + "EXPR [ (1, _1, _9) (-1, _10) 0 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _10, _0) 0 ], EXPR [ 5 ], EXPR [ 2 ]], outputs: [[_11, _12, _13, _14, _15]]", + "BLACKBOX::RANGE [(_11, 1)] []", + "BLACKBOX::RANGE [(_12, 1)] []", + "BLACKBOX::RANGE [(_13, 1)] []", + "BLACKBOX::RANGE [(_14, 1)] []", + "BLACKBOX::RANGE [(_15, 1)] []", + "EXPR [ (1, _0, _10) (-1, _11) (-2, _12) (-4, _13) (-8, _14) (-16, _15) 0 ]", + "EXPR [ (1, _15, _15) (2, _15) (-1, _16) 1 ]", + "EXPR [ (-1, _14) (-1, _17) 1 ]", + "EXPR [ (2, _14, _16) (1, _16, _17) (-1, _18) 0 ]", + "EXPR [ (1, _18, _18) (-1, _19) 0 ]", + "EXPR [ (-1, _13) (-1, _20) 1 ]", + "EXPR [ (2, _13, _19) (1, _19, _20) (-1, _21) 0 ]", + "EXPR [ (1, _21, _21) (-1, _22) 0 ]", + "EXPR [ (-1, _12) (-1, _23) 1 ]", + "EXPR [ (2, _12, _22) (1, _22, _23) (-1, _24) 0 ]", + "EXPR [ (1, _24, _24) (-1, _25) 0 ]", + "EXPR [ (-1, _11) (-1, _26) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 0 ], EXPR [ 32768 ]], outputs: [_27, _28]", + "BLACKBOX::RANGE [(_27, 1)] []", + "BLACKBOX::RANGE [(_28, 15)] []", + "EXPR [ (1, _1) (-32768, _27) (-1, _28) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _1) 131072 ], EXPR [ 131072 ]], outputs: [_29, _30]", + "BLACKBOX::RANGE [(_29, 1)] []", + "BLACKBOX::RANGE [(_30, 17)] []", + "EXPR [ (1, _1) (-131072, _29) (-1, _30) 131072 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _29, _27) (1, _1) (-1, _27) (-1, _29) 1 ], EXPR [ 65536 ]], outputs: [_31, _32]", + "BLACKBOX::RANGE [(_31, 1)] []", + "BLACKBOX::RANGE [(_32, 16)] []", + "EXPR [ (2, _27, _29) (1, _1) (-1, _27) (-1, _29) (-65536, _31) (-1, _32) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (2, _25, _11) (1, _25, _26) 0 ], EXPR [ 32768 ]], outputs: [_33, _34]", + "BLACKBOX::RANGE [(_33, 1)] []", + "BLACKBOX::RANGE [(_34, 15)] []", + "EXPR [ (2, _11, _25) (-1, _73) 0 ]", + "EXPR [ (1, _25, _26) (-1, _74) 0 ]", + "EXPR [ (-32768, _33) (-1, _34) (1, _73) (1, _74) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _32) 0 ], EXPR [ 32768 ]], outputs: [_35, _36]", + "BLACKBOX::RANGE [(_35, 1)] []", + "BLACKBOX::RANGE [(_36, 15)] []", + "EXPR [ (1, _32) (-32768, _35) (-1, _36) 0 ]", + "EXPR [ (-1, _37) (-1, _73) (-1, _74) 32768 ]", + "EXPR [ (2, _33, _37) (-1, _75) 0 ]", + "EXPR [ (-1, _38) (1, _73) (1, _74) (1, _75) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _38) 0 ]], outputs: [_39]", + "EXPR [ (1, _38, _39) (1, _40) -1 ]", + "EXPR [ (1, _38, _40) 0 ]", + "EXPR [ (1, _0, _40) 0 ]", + "BRILLIG CALL func 0: PREDICATE: EXPR [ (1, _0) 0 ]", + "inputs: [EXPR [ (-2, _32, _35) (1, _32) (65536, _35) 0 ], EXPR [ (2, _25, _11) (1, _25, _26) (2, _37, _33) 0 ]], outputs: [_41, _42]", + "BLACKBOX::RANGE [(_41, 16)] []", + "BLACKBOX::RANGE [(_42, 16)] []", + "EXPR [ (-1, _0) (-1, _42) (-1, _43) (1, _73) (1, _74) (1, _75) 0 ]", + "BLACKBOX::RANGE [(_43, 16)] []", + "EXPR [ (-1, _44) (1, _73) (1, _74) (1, _75) 0 ]", + "EXPR [ (1, _41, _44) (1, _42) (-1, _45) 0 ]", + "EXPR [ (-2, _32, _35) (1, _32) (65536, _35) (-1, _46) 0 ]", + "EXPR [ (-1, _0, _45) (1, _0, _46) 0 ]", + "EXPR [ (-1, _41) (-1, _47) 32768 ]", + "EXPR [ (-2, _33, _35) (1, _33) (1, _35) (-1, _48) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _41) 0 ]], outputs: [_49]", + "EXPR [ (1, _41, _49) (1, _50) -1 ]", + "EXPR [ (1, _41, _50) 0 ]", + "EXPR [ (2, _47, _48) (1, _41) (-1, _51) 0 ]", + "EXPR [ (-1, _50) (-1, _52) 1 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _42) 0 ]], outputs: [_53]", + "EXPR [ (1, _42, _53) (1, _54) -1 ]", + "EXPR [ (1, _42, _54) 0 ]", + "EXPR [ (-2, _35, _42) (65536, _35) (1, _42) (-1, _55) 0 ]", + "EXPR [ (-1, _54) (-1, _56) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-2, _29, _27) (1, _51, _52) (1, _27) (1, _29) 131071 ], EXPR [ 65536 ]], outputs: [_57, _58]", + "BLACKBOX::RANGE [(_57, 2)] []", + "BLACKBOX::RANGE [(_58, 16)] []", + "EXPR [ (-2, _27, _29) (1, _51, _52) (1, _27) (1, _29) (-65536, _57) (-1, _58) 131071 ]", + "EXPR [ (131070, _27, _29) (-65535, _27) (-65535, _29) (-1, _59) 65535 ]", + "EXPR [ (-1, _9) (-1, _60) 1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _9, _58) (1, _59, _60) 0 ], EXPR [ 65536 ]], outputs: [_61, _62]", + "BLACKBOX::RANGE [(_61, 1)] []", + "BLACKBOX::RANGE [(_62, 16)] []", + "EXPR [ (1, _9, _58) (1, _59, _60) (-65536, _61) (-1, _62) 0 ]", + "EXPR [ (-1, _0, _62) (1, _2) 0 ]", + "unconstrained func 0", + "[Const { destination: Direct(10), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(11), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(10), offset_address: Direct(11) }, BinaryFieldOp { destination: Direct(2), op: IntegerDiv, lhs: Direct(0), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Mul, lhs: Direct(2), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Sub, lhs: Direct(0), rhs: Direct(1) }, Mov { destination: Direct(0), source: Direct(2) }, Stop { return_data: HeapVector { pointer: Direct(11), size: Direct(10) } }]", + "unconstrained func 1", + "[Const { destination: Direct(5), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(6), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(7), bit_size: Integer(U32), value: 3 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(7), offset_address: Direct(5) }, Cast { destination: Direct(1), source: Direct(1), bit_size: Integer(U32) }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(7), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(3), op: IntegerDiv, lhs: Direct(0), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Mul, lhs: Direct(3), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Sub, lhs: Direct(0), rhs: Direct(4) }, Store { destination_pointer: Direct(9), source: Direct(4) }, BinaryIntOp { destination: Direct(9), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(6) }, Mov { destination: Direct(0), source: Direct(3) }, BinaryIntOp { destination: Direct(8), op: LessThan, bit_size: U32, lhs: Direct(9), rhs: Direct(7) }, JumpIf { condition: Direct(8), location: 7 }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, Stop { return_data: HeapVector { pointer: Direct(9), size: Direct(1) } }]", + "unconstrained func 2", + "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" + ], + "debug_symbols": "ddNLboMwEIDhu3jNIn6bXKWqIkKcCgkBcqBSFeXuNf6dNl10M8Ye5hPY47u4xPP2cRqm63wTx7e7OKdhHIeP0zj33TrMU169PxrxnJ7WFGNeEi/5XLV0KU6rOE7bODbisxu38tJt6aYyrl3K2UMj4nTJYwavwxj3p0fzW334v9SrWuvDT7HN1e951vVD+vO9QomjbIQu0ZRoS3Ql+hJDiW2J8sAgGSiX1EsAiSAhJIYEkSgKRaEoFIWiUBSKQlEoCkWhaBSNouuvoGgUjaJRNIpG0SgGxaAYFFN3BMWgGBSDYlAMikWxKBbFoti6sSgWxaJYFIviUByKQ3EoDsXV80FxKA7FoXgUj+JRPIpH8Si+HjOKR/EoASWgBJSAElACSkAJtVtQAkqL0qK0KC1KuyuPvZPT0J3HWC/QdZv6l/u0fi3PzPPGLWnu42VLce/lksvd/Q0=", + "file_map": { + "50": { + "source": "fn main(active: bool, a: pub i16) -> pub i16 {\n if active {\n (a >> a)\n } else {\n 0\n }\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "directive_integer_quotient", + "directive_to_radix", + "directive_invert" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..aa618610387 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -0,0 +1,69 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "active", + "type": { + "kind": "boolean" + }, + "visibility": "private" + }, + { + "name": "a", + "type": { + "kind": "integer", + "sign": "signed", + "width": 16 + }, + "visibility": "public" + } + ], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "signed", + "width": 16 + }, + "visibility": "public" + }, + "error_types": { + "14514982005979867414": { + "error_kind": "string", + "string": "attempt to bit-shift with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": [ + "func 0", + "current witness index : _2", + "private parameters indices : [_0]", + "public parameters indices : [_1]", + "return value indices : [_2]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ]], outputs: [_2]", + "unconstrained func 0", + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U1) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U16) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 16 }, Call { location: 17 }, Mov { destination: Direct(32838), source: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, Return, Call { location: 87 }, JumpIf { condition: Relative(1), location: 23 }, Jump { location: 20 }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 85 }, Cast { destination: Relative(1), source: Relative(2), bit_size: Integer(U16) }, Const { destination: Relative(4), bit_size: Integer(U16), value: 15 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U16, lhs: Relative(1), rhs: Relative(4) }, Const { destination: Relative(1), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(5), location: 29 }, Call { location: 93 }, Const { destination: Relative(5), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U16, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 33 }, Jump { location: 80 }, Const { destination: Relative(7), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U16, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 37 }, Jump { location: 77 }, Const { destination: Relative(8), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(10), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(11), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 48 }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U16, lhs: Relative(10), rhs: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Jump { location: 42 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U16, lhs: Relative(2), rhs: Relative(8) }, Const { destination: Relative(17), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U16, lhs: Relative(17), rhs: Relative(1) }, Const { destination: Relative(18), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U16, lhs: Relative(18), rhs: Relative(1) }, JumpIf { condition: Relative(12), location: 55 }, Jump { location: 57 }, Mov { destination: Relative(13), source: Relative(19) }, Jump { location: 59 }, Mov { destination: Relative(13), source: Relative(1) }, Jump { location: 59 }, Const { destination: Relative(17), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U16, lhs: Relative(17), rhs: Relative(10) }, Const { destination: Relative(18), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U16, lhs: Relative(18), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 65 }, Jump { location: 67 }, Mov { destination: Relative(15), source: Relative(19) }, Jump { location: 69 }, Mov { destination: Relative(15), source: Relative(10) }, Jump { location: 69 }, BinaryIntOp { destination: Relative(1), op: Div, bit_size: U16, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: Xor, bit_size: U1, lhs: Relative(12), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 73 }, Jump { location: 75 }, Const { destination: Relative(17), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U16, lhs: Relative(17), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U16, lhs: Relative(1), rhs: Relative(8) }, Jump { location: 79 }, Const { destination: Relative(1), bit_size: Integer(U16), value: 65535 }, Jump { location: 79 }, Jump { location: 82 }, BinaryIntOp { destination: Relative(1), op: Shr, bit_size: U16, lhs: Relative(2), rhs: Relative(2) }, Jump { location: 82 }, Mov { destination: Relative(2), source: Relative(1) }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 85 }, Mov { destination: Relative(1), source: Relative(3) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 92 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + ], + "debug_symbols": "ddLNjoIwFIbhe+m6C6B/4K0YYxCrIWkKqTDJxHDv0/rq6Cxm049SzkPSc+7i7E/r9TjGy3QTu/1dnNIYwng9hmnol3GK+e1dVGVplNjVUjSaMIQlHNES3SNURdREQ6AoFIWiUBSKQlEoGkWjaBSNolE0ikbRKBpFoxgUg2JQDIpBMSgGxaAYFINiUSyKRbEoFsWiWBSLYlEsikNxKA7FoTgUh+JQHIpDcSgtSovSFmXbpHj17bgk70vbPhqZ2zv3ycdF7OIaghRffVgfH93mPj5y6VM+raTw8Zwzg5cx+PK0yXd19X+pa561rv0tNrn6kHf9MKY/g7UVJ439Kfjn9rLG4eN0+Z5fJ6/BnNM0+POafJHe01nndd862TUHKep8KftOyc4ctvLrHw==", + "file_map": { + "50": { + "source": "fn main(active: bool, a: pub i16) -> pub i16 {\n if active {\n (a >> a)\n } else {\n 0\n }\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_true_inliner_0.snap new file mode 100644 index 00000000000..aa618610387 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_true_inliner_0.snap @@ -0,0 +1,69 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "active", + "type": { + "kind": "boolean" + }, + "visibility": "private" + }, + { + "name": "a", + "type": { + "kind": "integer", + "sign": "signed", + "width": 16 + }, + "visibility": "public" + } + ], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "signed", + "width": 16 + }, + "visibility": "public" + }, + "error_types": { + "14514982005979867414": { + "error_kind": "string", + "string": "attempt to bit-shift with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": [ + "func 0", + "current witness index : _2", + "private parameters indices : [_0]", + "public parameters indices : [_1]", + "return value indices : [_2]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ]], outputs: [_2]", + "unconstrained func 0", + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U1) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U16) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 16 }, Call { location: 17 }, Mov { destination: Direct(32838), source: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, Return, Call { location: 87 }, JumpIf { condition: Relative(1), location: 23 }, Jump { location: 20 }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 85 }, Cast { destination: Relative(1), source: Relative(2), bit_size: Integer(U16) }, Const { destination: Relative(4), bit_size: Integer(U16), value: 15 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U16, lhs: Relative(1), rhs: Relative(4) }, Const { destination: Relative(1), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(5), location: 29 }, Call { location: 93 }, Const { destination: Relative(5), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U16, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 33 }, Jump { location: 80 }, Const { destination: Relative(7), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U16, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 37 }, Jump { location: 77 }, Const { destination: Relative(8), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(10), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(11), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 48 }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U16, lhs: Relative(10), rhs: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Jump { location: 42 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U16, lhs: Relative(2), rhs: Relative(8) }, Const { destination: Relative(17), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U16, lhs: Relative(17), rhs: Relative(1) }, Const { destination: Relative(18), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U16, lhs: Relative(18), rhs: Relative(1) }, JumpIf { condition: Relative(12), location: 55 }, Jump { location: 57 }, Mov { destination: Relative(13), source: Relative(19) }, Jump { location: 59 }, Mov { destination: Relative(13), source: Relative(1) }, Jump { location: 59 }, Const { destination: Relative(17), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U16, lhs: Relative(17), rhs: Relative(10) }, Const { destination: Relative(18), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U16, lhs: Relative(18), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 65 }, Jump { location: 67 }, Mov { destination: Relative(15), source: Relative(19) }, Jump { location: 69 }, Mov { destination: Relative(15), source: Relative(10) }, Jump { location: 69 }, BinaryIntOp { destination: Relative(1), op: Div, bit_size: U16, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: Xor, bit_size: U1, lhs: Relative(12), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 73 }, Jump { location: 75 }, Const { destination: Relative(17), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U16, lhs: Relative(17), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U16, lhs: Relative(1), rhs: Relative(8) }, Jump { location: 79 }, Const { destination: Relative(1), bit_size: Integer(U16), value: 65535 }, Jump { location: 79 }, Jump { location: 82 }, BinaryIntOp { destination: Relative(1), op: Shr, bit_size: U16, lhs: Relative(2), rhs: Relative(2) }, Jump { location: 82 }, Mov { destination: Relative(2), source: Relative(1) }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 85 }, Mov { destination: Relative(1), source: Relative(3) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 92 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + ], + "debug_symbols": "ddLNjoIwFIbhe+m6C6B/4K0YYxCrIWkKqTDJxHDv0/rq6Cxm049SzkPSc+7i7E/r9TjGy3QTu/1dnNIYwng9hmnol3GK+e1dVGVplNjVUjSaMIQlHNES3SNURdREQ6AoFIWiUBSKQlEoGkWjaBSNolE0ikbRKBpFoxgUg2JQDIpBMSgGxaAYFINiUSyKRbEoFsWiWBSLYlEsikNxKA7FoTgUh+JQHIpDcSgtSovSFmXbpHj17bgk70vbPhqZ2zv3ycdF7OIaghRffVgfH93mPj5y6VM+raTw8Zwzg5cx+PK0yXd19X+pa561rv0tNrn6kHf9MKY/g7UVJ439Kfjn9rLG4eN0+Z5fJ6/BnNM0+POafJHe01nndd862TUHKep8KftOyc4ctvLrHw==", + "file_map": { + "50": { + "source": "fn main(active: bool, a: pub i16) -> pub i16 {\n if active {\n (a >> a)\n } else {\n 0\n }\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_true_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..aa618610387 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -0,0 +1,69 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "active", + "type": { + "kind": "boolean" + }, + "visibility": "private" + }, + { + "name": "a", + "type": { + "kind": "integer", + "sign": "signed", + "width": 16 + }, + "visibility": "public" + } + ], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "signed", + "width": 16 + }, + "visibility": "public" + }, + "error_types": { + "14514982005979867414": { + "error_kind": "string", + "string": "attempt to bit-shift with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": [ + "func 0", + "current witness index : _2", + "private parameters indices : [_0]", + "public parameters indices : [_1]", + "return value indices : [_2]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ]], outputs: [_2]", + "unconstrained func 0", + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U1) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U16) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 16 }, Call { location: 17 }, Mov { destination: Direct(32838), source: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, Return, Call { location: 87 }, JumpIf { condition: Relative(1), location: 23 }, Jump { location: 20 }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 85 }, Cast { destination: Relative(1), source: Relative(2), bit_size: Integer(U16) }, Const { destination: Relative(4), bit_size: Integer(U16), value: 15 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U16, lhs: Relative(1), rhs: Relative(4) }, Const { destination: Relative(1), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(5), location: 29 }, Call { location: 93 }, Const { destination: Relative(5), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U16, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 33 }, Jump { location: 80 }, Const { destination: Relative(7), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U16, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 37 }, Jump { location: 77 }, Const { destination: Relative(8), bit_size: Integer(U16), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U16), value: 2 }, Const { destination: Relative(10), bit_size: Integer(U16), value: 1 }, Cast { destination: Relative(11), source: Relative(2), bit_size: Integer(U32) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 48 }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U16, lhs: Relative(10), rhs: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Jump { location: 42 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U16, lhs: Relative(2), rhs: Relative(8) }, Const { destination: Relative(17), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U16, lhs: Relative(17), rhs: Relative(1) }, Const { destination: Relative(18), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U16, lhs: Relative(18), rhs: Relative(1) }, JumpIf { condition: Relative(12), location: 55 }, Jump { location: 57 }, Mov { destination: Relative(13), source: Relative(19) }, Jump { location: 59 }, Mov { destination: Relative(13), source: Relative(1) }, Jump { location: 59 }, Const { destination: Relative(17), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U16, lhs: Relative(17), rhs: Relative(10) }, Const { destination: Relative(18), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U16, lhs: Relative(18), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 65 }, Jump { location: 67 }, Mov { destination: Relative(15), source: Relative(19) }, Jump { location: 69 }, Mov { destination: Relative(15), source: Relative(10) }, Jump { location: 69 }, BinaryIntOp { destination: Relative(1), op: Div, bit_size: U16, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: Xor, bit_size: U1, lhs: Relative(12), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 73 }, Jump { location: 75 }, Const { destination: Relative(17), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U16, lhs: Relative(17), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U16, lhs: Relative(1), rhs: Relative(8) }, Jump { location: 79 }, Const { destination: Relative(1), bit_size: Integer(U16), value: 65535 }, Jump { location: 79 }, Jump { location: 82 }, BinaryIntOp { destination: Relative(1), op: Shr, bit_size: U16, lhs: Relative(2), rhs: Relative(2) }, Jump { location: 82 }, Mov { destination: Relative(2), source: Relative(1) }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 85 }, Mov { destination: Relative(1), source: Relative(3) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 92 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + ], + "debug_symbols": "ddLNjoIwFIbhe+m6C6B/4K0YYxCrIWkKqTDJxHDv0/rq6Cxm049SzkPSc+7i7E/r9TjGy3QTu/1dnNIYwng9hmnol3GK+e1dVGVplNjVUjSaMIQlHNES3SNURdREQ6AoFIWiUBSKQlEoGkWjaBSNolE0ikbRKBpFoxgUg2JQDIpBMSgGxaAYFINiUSyKRbEoFsWiWBSLYlEsikNxKA7FoTgUh+JQHIpDcSgtSovSFmXbpHj17bgk70vbPhqZ2zv3ycdF7OIaghRffVgfH93mPj5y6VM+raTw8Zwzg5cx+PK0yXd19X+pa561rv0tNrn6kHf9MKY/g7UVJ439Kfjn9rLG4eN0+Z5fJ6/BnNM0+POafJHe01nndd862TUHKep8KftOyc4ctvLrHw==", + "file_map": { + "50": { + "source": "fn main(active: bool, a: pub i16) -> pub i16 {\n if active {\n (a >> a)\n } else {\n 0\n }\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__stdout.snap b/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__stdout.snap new file mode 100644 index 00000000000..a6dc6bb4c34 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/inactive_signed_bitshift/execute__tests__stdout.snap @@ -0,0 +1,5 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: stdout +--- +[inactive_signed_bitshift] Circuit output: 0 diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__expanded.snap index a247007f499..cc5b9ca22eb 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__expanded.snap @@ -85,17 +85,17 @@ fn enc(value: [u8; N], value_length: Field) -> ([u8; 32], Field) { fn bitshift_literal_0() -> u64 { let mut bits: u64 = 0_u64; - bits = bits | (1_u64 << 0_u8); + bits = bits | (1_u64 << 0_u64); bits } fn bitshift_literal_4() -> u64 { let mut bits: u64 = 0_u64; - bits = bits | (1_u64 << 4_u8); + bits = bits | (1_u64 << 4_u64); bits } -fn bitshift_variable(idx: u8) -> u64 { +fn bitshift_variable(idx: u64) -> u64 { let mut bits: u64 = 0_u64; bits = bits | (1_u64 << idx); bits @@ -134,9 +134,9 @@ fn main(x: [u8; 5], z: Field, u: i16, v: i16) { assert(result_0 == 1_u64); let result_4: u64 = bitshift_literal_4(); assert(result_4 == 16_u64); - let result_0: u64 = bitshift_variable(0_u8); + let result_0: u64 = bitshift_variable(0_u64); assert(result_0 == 1_u64); - let result_4: u64 = bitshift_variable(4_u8); + let result_4: u64 = bitshift_variable(4_u64); assert(result_4 == 16_u64); assert((u % -13_i16) == 0_i16); assert((u % v) == 0_i16); diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index c5c5745bae8..dbb0270044f 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -369,10 +369,10 @@ expression: artifact "unconstrained func 1", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "pZjBbhs7DEX/xesshqRIif2Vh4fASZzCgOEEblygCPrvFUe8k2aRLuSN77EdnaFk0Zr4ffd0eLh+vz+en19+7L799757uBxPp+P3+9PL4/7t+HLur77/vtvh6f3b5XDoL+3+er+Pet1fDue33bfz9XS62/3cn67rH/143Z/XfNtf+rvL3e5wfurZhc/H0yHo993H6OXrocyL5Whmtk2gnw30taEUTUHRdtv4KhPj1STHa6Ubx8/MXx0LaLxMjLe6jfeZ+k0Z421mfC2Yf7U6M95Ljm8LT4xvW/1tav/4gv3jNLN/Wq24vs98frRsBdDCMyvgzrcJiBbMgWhqEfqorQYqPmWwshnq1CyYHQaWqRp428vEU5vpUw3qtxrsy8/in1/J4ttXcqlThoojgcviEwbpw9IghexWA9OUQXQzlOVmg04Z9GMWZrca6tw6tI9ZtHqrweVmw9SO0q0vRKXMGcqHYerTVJJbDUaboU6tpBb/yvB/f7Z/PF4+3STuau/iu11bH319pGUEjeARMqKM0BE2YjioS/oCkK/Bywga0S39I2YZUUboiG7pNylcR7QRvoZ0Sz98hEbwCBnRLX2yoiNsRB3R4qDo6SPLkkmZnCmZJVMzLb5ge9bMlukjddSloy7l9aIqI0ZdOupSG0atmVmZZmWWlVlWZlmZZWVWxhVNM7Myy8qsrZcxX6MuI2hEuPqurpIZrr7iVTMts2ZGbX3Vq49sSyZlcqZklkzNtMyaGb7WM1fNc65O+ZzHdV0ysz7P+jx9nj7P+jzr6zdHAAIwQAAFoAAbZfX7mr5xY8susf9LgCesTbACARgQraABBaAAA1RAA3hCNMYAAjAAZoaZYWaYGWaGmWEWmAVmgTlahmPu0TRcAxRggApoAE+I9hlAAAYIAOYCc4G5wFxgLjArzAqzwqwwK8wKs8KsMCvMCrPBbDAbzNFbHBsgmisODoruGmCACmgAT4gmG0AABggA5gpzhbnCXGGuMDeYG8wN5gZzNJ0sAd0sFGCACmgAT4jWG0AABgigAGB2mB3maMG4mafowQCOHhxAAAYIoAAUYIAKaACYCWaCmWAmmAlmgplgJpjXg2k9i8Jc4jRaAARggAAKQAEGqIAGgFlgFpgFZoFZYBaYowdlPR8roAE8IXpwAAEYIIACUADMBeYCc4FZYVaYFWaFWWFWmBVmhVlhVpgNZoPZYDaYDeboQYmjP3pQakAFNIAnRA8OIAADBFAACoC5wlxhrjA3mBvMDeYGc4O5wdxgbjA3mBvMDrPD7DA7zA7z2oPxT+bP/eW4fzgd8ie95+v58a9f+N5+veId/Ab4enl5PDxdL4e40Vvf67d+fwA=", + "debug_symbols": "pZjBbttKDEX/xessRM6QnOmvPDwETuIUBgwncJMCRdB/71DkVZqFuxhvco/t8JiShtLAH7unw8P79/vj+fnlx+7bfx+7h8vxdDp+vz+9PO7fji/n8e7H77sdXt6/XQ6H8dbur89H1ev+cji/7b6d30+nu93P/el9/acfr/vzmm/7y/h0udsdzk8jh/D5eDo4/b77rF6ulzIvltXMbJtAvhrouqFWSUGVdlu9lYl60ZL1YnRjvc7Ud8165WWiXm2r7zP9qzDqdabeKo7fdOb6W69Z3xaeqG9b/21q/fQF66fTzPpphgFofeb60bI1QAvPnIHe+TYB0TbERFMnYVRtPVDtUwatm8GmjoK5w8Blqgfe1jLx1GL60oP0Ww169Vr885Zcl+2WXNuUwQiGSsuEoYyyNAy0Ww3XV/U/DUU3Q6WbDTpl0M+jULvVYHPnoX0eRWu3Gnq90SDL1IqSsp0HKTJlYPk0TF1NoXqrQXkz2NSZFFmuGf4fr/aPx8uXTeLOxhTf7dr6t69/aYmgCI4oETVCIjQiHDQk4wZJfQ1eIihiWMbp5RJRIyRiWMblZ4toEX2NMizj4VMogiNKxLCMm2GRCI2wiOYPipE9si6ZlMmZJbNmSqb6DXakZbbMHinRl0RfwuuXSomIviT6Eg2jWGZ2JtmZZmeanWl2ptmZ1vhGlczsTLMzbevXaF/DlgiKcNdYk1Yy3TXOuEmmZlqm9zbOuvXItmRSJmeWzJopmZppme5rI/Os9TzWTvma43t7ycz+evbX09fT17O/nv2NzRGAAAwogAoQgEZbY18zFq4v2cXXf3XoCesQrEAABvgoiEMFCEABBmiAnuCDEUAABsDMMDPMDDPDzDAzzAXmAnOB2UeG/dh9aNgcBKAAAzRAT/DxCSAAAwoA5gpzhbnCXGGuMAvMArPALDALzAKzwCwwC8wCs8KsMCvMPlvsC8CHyzdU5NMVoAADNEBP8CELIAADCgBmg9lgNpgNZoO5wdxgbjA3mH3o/GFHPnWFHBRggAboCT56AQRgQAFUAMwd5g6zj6Bv5sln0IF9BgMIwIACqAABKMAADQAzwUwwE8wEM8FMMBPMBPP6YFqfRW6u/jRaAARgQAFUgAAUYIAGgLnAXGAuMBeYC8wFZp/Bsj4fDdAAPcFnMIAADCiAChAAzBXmCnOFWWAWmAVmgVlgFpgFZoFZYBaYFWaFWWFWmBVmn0HfUbPPYDEHAzRAT/AZDCAAAwqgAgQAs8FsMBvMDeYGc4O5wdxgbjA3mBvMDeYGc4e5w9xh7jB3mNcZ9O34z/3luH84HfInvef38+Nfv/C9/XrFJ/gN8PXy8nh4er8cfKO3fja2fn8A", "file_map": { "50": { - "source": "global NIBBLE_LENGTH: u32 = 16;\n\nstruct U4 {\n inner: u8,\n}\n\nimpl U4 {\n fn zero() -> U4 {\n U4 { inner: 0 }\n }\n\n fn from_u8(x: u8) -> U4 {\n U4 { inner: x % 16 }\n }\n}\n\nimpl Eq for U4 {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nfn compact_decode(input: [u8; N], length: Field) -> ([U4; NIBBLE_LENGTH], Field) {\n assert(2 * input.len() <= NIBBLE_LENGTH);\n assert(length as u32 <= input.len());\n\n let mut nibble = [U4::zero(); NIBBLE_LENGTH];\n\n let first_nibble = U4::from_u8(input[0] >> 4);\n let parity = first_nibble.inner as u1;\n\n if parity == 1 {\n nibble[0] = U4::from_u8(input[0] & 0x0f);\n for i in 1..input.len() {\n if i as u32 < length as u32 {\n let x = input[i];\n nibble[2 * i - 1] = U4::from_u8(x >> 4);\n nibble[2 * i] = U4::from_u8(x & 0x0f);\n }\n }\n } else {\n for i in 0..2 {\n if (i as u32) < length as u32 - 1 {\n let x = input[i + 1];\n nibble[2 * i] = U4::from_u8(x >> 4);\n nibble[2 * i + 1] = U4::from_u8(x & 0x0f);\n }\n }\n }\n\n let out = (nibble, 2 * length + (parity as Field) - 2);\n\n out\n}\n\nfn enc(value: [u8; N], value_length: Field) -> ([u8; 32], Field) {\n assert(value.len() as u8 >= value_length as u8);\n let mut out_value = [0; 32];\n if value_length == 0 {\n let out = (out_value, value_length);\n out\n } else if value_length as u8 < 31 {\n out_value[0] = 0x80 + value_length as u8;\n\n for i in 1..value.len() {\n out_value[i] = value[i - 1];\n }\n\n let out = (out_value, value_length + 1);\n\n out\n } else {\n let out = (out_value, 32);\n out\n }\n}\n\nfn bitshift_literal_0() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 0;\n\n bits\n}\nfn bitshift_literal_4() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 4;\n\n bits\n}\nfn bitshift_variable(idx: u8) -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << idx;\n\n bits\n}\n\nfn main(x: [u8; 5], z: Field, u: i16, v: i16) {\n //Issue 1144\n let (nib, len) = compact_decode(x, z);\n assert(len == 5);\n assert(\n [nib[0], nib[1], nib[2], nib[3], nib[4]]\n == [U4::from_u8(15), U4::from_u8(1), U4::from_u8(12), U4::from_u8(11), U4::from_u8(8)],\n );\n // Issue 1169\n let val1 = [\n 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41, 0x12, 0x13,\n 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00,\n ];\n let val1_length = 20;\n\n let enc_val1 = enc(val1, val1_length);\n\n assert(\n enc_val1.0\n == [\n 0x94, 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41,\n 0x12, 0x13, 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00,\n ],\n );\n assert(enc_val1.1 == 21);\n // Issue 2399\n let result_0 = bitshift_literal_0();\n assert(result_0 == 1);\n let result_4 = bitshift_literal_4();\n assert(result_4 == 16);\n let result_0 = bitshift_variable(0);\n assert(result_0 == 1);\n let result_4 = bitshift_variable(4);\n assert(result_4 == 16);\n\n // Issue 6609\n assert(u % -13 == 0);\n assert(u % v == 0);\n assert(u % -11 == 4);\n assert(-u % -11 == -4);\n assert(u % -11 == u % (v + 2));\n assert(-u % -11 == -u % (v + 2));\n}\n", + "source": "global NIBBLE_LENGTH: u32 = 16;\n\nstruct U4 {\n inner: u8,\n}\n\nimpl U4 {\n fn zero() -> U4 {\n U4 { inner: 0 }\n }\n\n fn from_u8(x: u8) -> U4 {\n U4 { inner: x % 16 }\n }\n}\n\nimpl Eq for U4 {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nfn compact_decode(input: [u8; N], length: Field) -> ([U4; NIBBLE_LENGTH], Field) {\n assert(2 * input.len() <= NIBBLE_LENGTH);\n assert(length as u32 <= input.len());\n\n let mut nibble = [U4::zero(); NIBBLE_LENGTH];\n\n let first_nibble = U4::from_u8(input[0] >> 4);\n let parity = first_nibble.inner as u1;\n\n if parity == 1 {\n nibble[0] = U4::from_u8(input[0] & 0x0f);\n for i in 1..input.len() {\n if i as u32 < length as u32 {\n let x = input[i];\n nibble[2 * i - 1] = U4::from_u8(x >> 4);\n nibble[2 * i] = U4::from_u8(x & 0x0f);\n }\n }\n } else {\n for i in 0..2 {\n if (i as u32) < length as u32 - 1 {\n let x = input[i + 1];\n nibble[2 * i] = U4::from_u8(x >> 4);\n nibble[2 * i + 1] = U4::from_u8(x & 0x0f);\n }\n }\n }\n\n let out = (nibble, 2 * length + (parity as Field) - 2);\n\n out\n}\n\nfn enc(value: [u8; N], value_length: Field) -> ([u8; 32], Field) {\n assert(value.len() as u8 >= value_length as u8);\n let mut out_value = [0; 32];\n if value_length == 0 {\n let out = (out_value, value_length);\n out\n } else if value_length as u8 < 31 {\n out_value[0] = 0x80 + value_length as u8;\n\n for i in 1..value.len() {\n out_value[i] = value[i - 1];\n }\n\n let out = (out_value, value_length + 1);\n\n out\n } else {\n let out = (out_value, 32);\n out\n }\n}\n\nfn bitshift_literal_0() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 0;\n\n bits\n}\nfn bitshift_literal_4() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 4;\n\n bits\n}\nfn bitshift_variable(idx: u64) -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << idx;\n\n bits\n}\n\nfn main(x: [u8; 5], z: Field, u: i16, v: i16) {\n //Issue 1144\n let (nib, len) = compact_decode(x, z);\n assert(len == 5);\n assert(\n [nib[0], nib[1], nib[2], nib[3], nib[4]]\n == [U4::from_u8(15), U4::from_u8(1), U4::from_u8(12), U4::from_u8(11), U4::from_u8(8)],\n );\n // Issue 1169\n let val1 = [\n 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41, 0x12, 0x13,\n 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00,\n ];\n let val1_length = 20;\n\n let enc_val1 = enc(val1, val1_length);\n\n assert(\n enc_val1.0\n == [\n 0x94, 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41,\n 0x12, 0x13, 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00,\n ],\n );\n assert(enc_val1.1 == 21);\n // Issue 2399\n let result_0 = bitshift_literal_0();\n assert(result_0 == 1);\n let result_4 = bitshift_literal_4();\n assert(result_4 == 16);\n let result_0 = bitshift_variable(0);\n assert(result_0 == 1);\n let result_4 = bitshift_variable(4);\n assert(result_4 == 16);\n\n // Issue 6609\n assert(u % -13 == 0);\n assert(u % v == 0);\n assert(u % -11 == 4);\n assert(-u % -11 == -4);\n assert(u % -11 == u % (v + 2));\n assert(-u % -11 == -u % (v + 2));\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_false_inliner_0.snap index c5c5745bae8..dbb0270044f 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_false_inliner_0.snap @@ -369,10 +369,10 @@ expression: artifact "unconstrained func 1", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "pZjBbhs7DEX/xesshqRIif2Vh4fASZzCgOEEblygCPrvFUe8k2aRLuSN77EdnaFk0Zr4ffd0eLh+vz+en19+7L799757uBxPp+P3+9PL4/7t+HLur77/vtvh6f3b5XDoL+3+er+Pet1fDue33bfz9XS62/3cn67rH/143Z/XfNtf+rvL3e5wfurZhc/H0yHo993H6OXrocyL5Whmtk2gnw30taEUTUHRdtv4KhPj1STHa6Ubx8/MXx0LaLxMjLe6jfeZ+k0Z421mfC2Yf7U6M95Ljm8LT4xvW/1tav/4gv3jNLN/Wq24vs98frRsBdDCMyvgzrcJiBbMgWhqEfqorQYqPmWwshnq1CyYHQaWqRp428vEU5vpUw3qtxrsy8/in1/J4ttXcqlThoojgcviEwbpw9IghexWA9OUQXQzlOVmg04Z9GMWZrca6tw6tI9ZtHqrweVmw9SO0q0vRKXMGcqHYerTVJJbDUaboU6tpBb/yvB/f7Z/PF4+3STuau/iu11bH319pGUEjeARMqKM0BE2YjioS/oCkK/Bywga0S39I2YZUUboiG7pNylcR7QRvoZ0Sz98hEbwCBnRLX2yoiNsRB3R4qDo6SPLkkmZnCmZJVMzLb5ge9bMlukjddSloy7l9aIqI0ZdOupSG0atmVmZZmWWlVlWZlmZZWVWxhVNM7Myy8qsrZcxX6MuI2hEuPqurpIZrr7iVTMts2ZGbX3Vq49sSyZlcqZklkzNtMyaGb7WM1fNc65O+ZzHdV0ysz7P+jx9nj7P+jzr6zdHAAIwQAAFoAAbZfX7mr5xY8susf9LgCesTbACARgQraABBaAAA1RAA3hCNMYAAjAAZoaZYWaYGWaGmWEWmAVmgTlahmPu0TRcAxRggApoAE+I9hlAAAYIAOYCc4G5wFxgLjArzAqzwqwwK8wKs8KsMCvMCrPBbDAbzNFbHBsgmisODoruGmCACmgAT4gmG0AABggA5gpzhbnCXGGuMDeYG8wN5gZzNJ0sAd0sFGCACmgAT4jWG0AABgigAGB2mB3maMG4mafowQCOHhxAAAYIoAAUYIAKaACYCWaCmWAmmAlmgplgJpjXg2k9i8Jc4jRaAARggAAKQAEGqIAGgFlgFpgFZoFZYBaYowdlPR8roAE8IXpwAAEYIIACUADMBeYCc4FZYVaYFWaFWWFWmBVmhVlhVpgNZoPZYDaYDeboQYmjP3pQakAFNIAnRA8OIAADBFAACoC5wlxhrjA3mBvMDeYGc4O5wdxgbjA3mBvMDrPD7DA7zA7z2oPxT+bP/eW4fzgd8ie95+v58a9f+N5+veId/Ab4enl5PDxdL4e40Vvf67d+fwA=", + "debug_symbols": "pZjBbttKDEX/xessRM6QnOmvPDwETuIUBgwncJMCRdB/71DkVZqFuxhvco/t8JiShtLAH7unw8P79/vj+fnlx+7bfx+7h8vxdDp+vz+9PO7fji/n8e7H77sdXt6/XQ6H8dbur89H1ev+cji/7b6d30+nu93P/el9/acfr/vzmm/7y/h0udsdzk8jh/D5eDo4/b77rF6ulzIvltXMbJtAvhrouqFWSUGVdlu9lYl60ZL1YnRjvc7Ud8165WWiXm2r7zP9qzDqdabeKo7fdOb6W69Z3xaeqG9b/21q/fQF66fTzPpphgFofeb60bI1QAvPnIHe+TYB0TbERFMnYVRtPVDtUwatm8GmjoK5w8Blqgfe1jLx1GL60oP0Ww169Vr885Zcl+2WXNuUwQiGSsuEoYyyNAy0Ww3XV/U/DUU3Q6WbDTpl0M+jULvVYHPnoX0eRWu3Gnq90SDL1IqSsp0HKTJlYPk0TF1NoXqrQXkz2NSZFFmuGf4fr/aPx8uXTeLOxhTf7dr6t69/aYmgCI4oETVCIjQiHDQk4wZJfQ1eIihiWMbp5RJRIyRiWMblZ4toEX2NMizj4VMogiNKxLCMm2GRCI2wiOYPipE9si6ZlMmZJbNmSqb6DXakZbbMHinRl0RfwuuXSomIviT6Eg2jWGZ2JtmZZmeanWl2ptmZ1vhGlczsTLMzbevXaF/DlgiKcNdYk1Yy3TXOuEmmZlqm9zbOuvXItmRSJmeWzJopmZppme5rI/Os9TzWTvma43t7ycz+evbX09fT17O/nv2NzRGAAAwogAoQgEZbY18zFq4v2cXXf3XoCesQrEAABvgoiEMFCEABBmiAnuCDEUAABsDMMDPMDDPDzDAzzAXmAnOB2UeG/dh9aNgcBKAAAzRAT/DxCSAAAwoA5gpzhbnCXGGuMAvMArPALDALzAKzwCwwC8wCs8KsMCvMPlvsC8CHyzdU5NMVoAADNEBP8CELIAADCgBmg9lgNpgNZoO5wdxgbjA3mH3o/GFHPnWFHBRggAboCT56AQRgQAFUAMwd5g6zj6Bv5sln0IF9BgMIwIACqAABKMAADQAzwUwwE8wEM8FMMBPMBPP6YFqfRW6u/jRaAARgQAFUgAAUYIAGgLnAXGAuMBeYC8wFZp/Bsj4fDdAAPcFnMIAADCiAChAAzBXmCnOFWWAWmAVmgVlgFpgFZoFZYBaYFWaFWWFWmBVmn0HfUbPPYDEHAzRAT/AZDCAAAwqgAgQAs8FsMBvMDeYGc4O5wdxgbjA3mBvMDeYGc4e5w9xh7jB3mNcZ9O34z/3luH84HfInvef38+Nfv/C9/XrFJ/gN8PXy8nh4er8cfKO3fja2fn8A", "file_map": { "50": { - "source": "global NIBBLE_LENGTH: u32 = 16;\n\nstruct U4 {\n inner: u8,\n}\n\nimpl U4 {\n fn zero() -> U4 {\n U4 { inner: 0 }\n }\n\n fn from_u8(x: u8) -> U4 {\n U4 { inner: x % 16 }\n }\n}\n\nimpl Eq for U4 {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nfn compact_decode(input: [u8; N], length: Field) -> ([U4; NIBBLE_LENGTH], Field) {\n assert(2 * input.len() <= NIBBLE_LENGTH);\n assert(length as u32 <= input.len());\n\n let mut nibble = [U4::zero(); NIBBLE_LENGTH];\n\n let first_nibble = U4::from_u8(input[0] >> 4);\n let parity = first_nibble.inner as u1;\n\n if parity == 1 {\n nibble[0] = U4::from_u8(input[0] & 0x0f);\n for i in 1..input.len() {\n if i as u32 < length as u32 {\n let x = input[i];\n nibble[2 * i - 1] = U4::from_u8(x >> 4);\n nibble[2 * i] = U4::from_u8(x & 0x0f);\n }\n }\n } else {\n for i in 0..2 {\n if (i as u32) < length as u32 - 1 {\n let x = input[i + 1];\n nibble[2 * i] = U4::from_u8(x >> 4);\n nibble[2 * i + 1] = U4::from_u8(x & 0x0f);\n }\n }\n }\n\n let out = (nibble, 2 * length + (parity as Field) - 2);\n\n out\n}\n\nfn enc(value: [u8; N], value_length: Field) -> ([u8; 32], Field) {\n assert(value.len() as u8 >= value_length as u8);\n let mut out_value = [0; 32];\n if value_length == 0 {\n let out = (out_value, value_length);\n out\n } else if value_length as u8 < 31 {\n out_value[0] = 0x80 + value_length as u8;\n\n for i in 1..value.len() {\n out_value[i] = value[i - 1];\n }\n\n let out = (out_value, value_length + 1);\n\n out\n } else {\n let out = (out_value, 32);\n out\n }\n}\n\nfn bitshift_literal_0() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 0;\n\n bits\n}\nfn bitshift_literal_4() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 4;\n\n bits\n}\nfn bitshift_variable(idx: u8) -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << idx;\n\n bits\n}\n\nfn main(x: [u8; 5], z: Field, u: i16, v: i16) {\n //Issue 1144\n let (nib, len) = compact_decode(x, z);\n assert(len == 5);\n assert(\n [nib[0], nib[1], nib[2], nib[3], nib[4]]\n == [U4::from_u8(15), U4::from_u8(1), U4::from_u8(12), U4::from_u8(11), U4::from_u8(8)],\n );\n // Issue 1169\n let val1 = [\n 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41, 0x12, 0x13,\n 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00,\n ];\n let val1_length = 20;\n\n let enc_val1 = enc(val1, val1_length);\n\n assert(\n enc_val1.0\n == [\n 0x94, 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41,\n 0x12, 0x13, 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00,\n ],\n );\n assert(enc_val1.1 == 21);\n // Issue 2399\n let result_0 = bitshift_literal_0();\n assert(result_0 == 1);\n let result_4 = bitshift_literal_4();\n assert(result_4 == 16);\n let result_0 = bitshift_variable(0);\n assert(result_0 == 1);\n let result_4 = bitshift_variable(4);\n assert(result_4 == 16);\n\n // Issue 6609\n assert(u % -13 == 0);\n assert(u % v == 0);\n assert(u % -11 == 4);\n assert(-u % -11 == -4);\n assert(u % -11 == u % (v + 2));\n assert(-u % -11 == -u % (v + 2));\n}\n", + "source": "global NIBBLE_LENGTH: u32 = 16;\n\nstruct U4 {\n inner: u8,\n}\n\nimpl U4 {\n fn zero() -> U4 {\n U4 { inner: 0 }\n }\n\n fn from_u8(x: u8) -> U4 {\n U4 { inner: x % 16 }\n }\n}\n\nimpl Eq for U4 {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nfn compact_decode(input: [u8; N], length: Field) -> ([U4; NIBBLE_LENGTH], Field) {\n assert(2 * input.len() <= NIBBLE_LENGTH);\n assert(length as u32 <= input.len());\n\n let mut nibble = [U4::zero(); NIBBLE_LENGTH];\n\n let first_nibble = U4::from_u8(input[0] >> 4);\n let parity = first_nibble.inner as u1;\n\n if parity == 1 {\n nibble[0] = U4::from_u8(input[0] & 0x0f);\n for i in 1..input.len() {\n if i as u32 < length as u32 {\n let x = input[i];\n nibble[2 * i - 1] = U4::from_u8(x >> 4);\n nibble[2 * i] = U4::from_u8(x & 0x0f);\n }\n }\n } else {\n for i in 0..2 {\n if (i as u32) < length as u32 - 1 {\n let x = input[i + 1];\n nibble[2 * i] = U4::from_u8(x >> 4);\n nibble[2 * i + 1] = U4::from_u8(x & 0x0f);\n }\n }\n }\n\n let out = (nibble, 2 * length + (parity as Field) - 2);\n\n out\n}\n\nfn enc(value: [u8; N], value_length: Field) -> ([u8; 32], Field) {\n assert(value.len() as u8 >= value_length as u8);\n let mut out_value = [0; 32];\n if value_length == 0 {\n let out = (out_value, value_length);\n out\n } else if value_length as u8 < 31 {\n out_value[0] = 0x80 + value_length as u8;\n\n for i in 1..value.len() {\n out_value[i] = value[i - 1];\n }\n\n let out = (out_value, value_length + 1);\n\n out\n } else {\n let out = (out_value, 32);\n out\n }\n}\n\nfn bitshift_literal_0() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 0;\n\n bits\n}\nfn bitshift_literal_4() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 4;\n\n bits\n}\nfn bitshift_variable(idx: u64) -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << idx;\n\n bits\n}\n\nfn main(x: [u8; 5], z: Field, u: i16, v: i16) {\n //Issue 1144\n let (nib, len) = compact_decode(x, z);\n assert(len == 5);\n assert(\n [nib[0], nib[1], nib[2], nib[3], nib[4]]\n == [U4::from_u8(15), U4::from_u8(1), U4::from_u8(12), U4::from_u8(11), U4::from_u8(8)],\n );\n // Issue 1169\n let val1 = [\n 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41, 0x12, 0x13,\n 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00,\n ];\n let val1_length = 20;\n\n let enc_val1 = enc(val1, val1_length);\n\n assert(\n enc_val1.0\n == [\n 0x94, 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41,\n 0x12, 0x13, 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00,\n ],\n );\n assert(enc_val1.1 == 21);\n // Issue 2399\n let result_0 = bitshift_literal_0();\n assert(result_0 == 1);\n let result_4 = bitshift_literal_4();\n assert(result_4 == 16);\n let result_0 = bitshift_variable(0);\n assert(result_0 == 1);\n let result_4 = bitshift_variable(4);\n assert(result_4 == 16);\n\n // Issue 6609\n assert(u % -13 == 0);\n assert(u % v == 0);\n assert(u % -11 == 4);\n assert(-u % -11 == -4);\n assert(u % -11 == u % (v + 2));\n assert(-u % -11 == -u % (v + 2));\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index c5c5745bae8..dbb0270044f 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -369,10 +369,10 @@ expression: artifact "unconstrained func 1", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "pZjBbhs7DEX/xesshqRIif2Vh4fASZzCgOEEblygCPrvFUe8k2aRLuSN77EdnaFk0Zr4ffd0eLh+vz+en19+7L799757uBxPp+P3+9PL4/7t+HLur77/vtvh6f3b5XDoL+3+er+Pet1fDue33bfz9XS62/3cn67rH/143Z/XfNtf+rvL3e5wfurZhc/H0yHo993H6OXrocyL5Whmtk2gnw30taEUTUHRdtv4KhPj1STHa6Ubx8/MXx0LaLxMjLe6jfeZ+k0Z421mfC2Yf7U6M95Ljm8LT4xvW/1tav/4gv3jNLN/Wq24vs98frRsBdDCMyvgzrcJiBbMgWhqEfqorQYqPmWwshnq1CyYHQaWqRp428vEU5vpUw3qtxrsy8/in1/J4ttXcqlThoojgcviEwbpw9IghexWA9OUQXQzlOVmg04Z9GMWZrca6tw6tI9ZtHqrweVmw9SO0q0vRKXMGcqHYerTVJJbDUaboU6tpBb/yvB/f7Z/PF4+3STuau/iu11bH319pGUEjeARMqKM0BE2YjioS/oCkK/Bywga0S39I2YZUUboiG7pNylcR7QRvoZ0Sz98hEbwCBnRLX2yoiNsRB3R4qDo6SPLkkmZnCmZJVMzLb5ge9bMlukjddSloy7l9aIqI0ZdOupSG0atmVmZZmWWlVlWZlmZZWVWxhVNM7Myy8qsrZcxX6MuI2hEuPqurpIZrr7iVTMts2ZGbX3Vq49sSyZlcqZklkzNtMyaGb7WM1fNc65O+ZzHdV0ysz7P+jx9nj7P+jzr6zdHAAIwQAAFoAAbZfX7mr5xY8susf9LgCesTbACARgQraABBaAAA1RAA3hCNMYAAjAAZoaZYWaYGWaGmWEWmAVmgTlahmPu0TRcAxRggApoAE+I9hlAAAYIAOYCc4G5wFxgLjArzAqzwqwwK8wKs8KsMCvMCrPBbDAbzNFbHBsgmisODoruGmCACmgAT4gmG0AABggA5gpzhbnCXGGuMDeYG8wN5gZzNJ0sAd0sFGCACmgAT4jWG0AABgigAGB2mB3maMG4mafowQCOHhxAAAYIoAAUYIAKaACYCWaCmWAmmAlmgplgJpjXg2k9i8Jc4jRaAARggAAKQAEGqIAGgFlgFpgFZoFZYBaYowdlPR8roAE8IXpwAAEYIIACUADMBeYCc4FZYVaYFWaFWWFWmBVmhVlhVpgNZoPZYDaYDeboQYmjP3pQakAFNIAnRA8OIAADBFAACoC5wlxhrjA3mBvMDeYGc4O5wdxgbjA3mBvMDrPD7DA7zA7z2oPxT+bP/eW4fzgd8ie95+v58a9f+N5+veId/Ab4enl5PDxdL4e40Vvf67d+fwA=", + "debug_symbols": "pZjBbttKDEX/xessRM6QnOmvPDwETuIUBgwncJMCRdB/71DkVZqFuxhvco/t8JiShtLAH7unw8P79/vj+fnlx+7bfx+7h8vxdDp+vz+9PO7fji/n8e7H77sdXt6/XQ6H8dbur89H1ev+cji/7b6d30+nu93P/el9/acfr/vzmm/7y/h0udsdzk8jh/D5eDo4/b77rF6ulzIvltXMbJtAvhrouqFWSUGVdlu9lYl60ZL1YnRjvc7Ud8165WWiXm2r7zP9qzDqdabeKo7fdOb6W69Z3xaeqG9b/21q/fQF66fTzPpphgFofeb60bI1QAvPnIHe+TYB0TbERFMnYVRtPVDtUwatm8GmjoK5w8Blqgfe1jLx1GL60oP0Ww169Vr885Zcl+2WXNuUwQiGSsuEoYyyNAy0Ww3XV/U/DUU3Q6WbDTpl0M+jULvVYHPnoX0eRWu3Gnq90SDL1IqSsp0HKTJlYPk0TF1NoXqrQXkz2NSZFFmuGf4fr/aPx8uXTeLOxhTf7dr6t69/aYmgCI4oETVCIjQiHDQk4wZJfQ1eIihiWMbp5RJRIyRiWMblZ4toEX2NMizj4VMogiNKxLCMm2GRCI2wiOYPipE9si6ZlMmZJbNmSqb6DXakZbbMHinRl0RfwuuXSomIviT6Eg2jWGZ2JtmZZmeanWl2ptmZ1vhGlczsTLMzbevXaF/DlgiKcNdYk1Yy3TXOuEmmZlqm9zbOuvXItmRSJmeWzJopmZppme5rI/Os9TzWTvma43t7ycz+evbX09fT17O/nv2NzRGAAAwogAoQgEZbY18zFq4v2cXXf3XoCesQrEAABvgoiEMFCEABBmiAnuCDEUAABsDMMDPMDDPDzDAzzAXmAnOB2UeG/dh9aNgcBKAAAzRAT/DxCSAAAwoA5gpzhbnCXGGuMAvMArPALDALzAKzwCwwC8wCs8KsMCvMPlvsC8CHyzdU5NMVoAADNEBP8CELIAADCgBmg9lgNpgNZoO5wdxgbjA3mH3o/GFHPnWFHBRggAboCT56AQRgQAFUAMwd5g6zj6Bv5sln0IF9BgMIwIACqAABKMAADQAzwUwwE8wEM8FMMBPMBPP6YFqfRW6u/jRaAARgQAFUgAAUYIAGgLnAXGAuMBeYC8wFZp/Bsj4fDdAAPcFnMIAADCiAChAAzBXmCnOFWWAWmAVmgVlgFpgFZoFZYBaYFWaFWWFWmBVmn0HfUbPPYDEHAzRAT/AZDCAAAwqgAgQAs8FsMBvMDeYGc4O5wdxgbjA3mBvMDeYGc4e5w9xh7jB3mNcZ9O34z/3luH84HfInvef38+Nfv/C9/XrFJ/gN8PXy8nh4er8cfKO3fja2fn8A", "file_map": { "50": { - "source": "global NIBBLE_LENGTH: u32 = 16;\n\nstruct U4 {\n inner: u8,\n}\n\nimpl U4 {\n fn zero() -> U4 {\n U4 { inner: 0 }\n }\n\n fn from_u8(x: u8) -> U4 {\n U4 { inner: x % 16 }\n }\n}\n\nimpl Eq for U4 {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nfn compact_decode(input: [u8; N], length: Field) -> ([U4; NIBBLE_LENGTH], Field) {\n assert(2 * input.len() <= NIBBLE_LENGTH);\n assert(length as u32 <= input.len());\n\n let mut nibble = [U4::zero(); NIBBLE_LENGTH];\n\n let first_nibble = U4::from_u8(input[0] >> 4);\n let parity = first_nibble.inner as u1;\n\n if parity == 1 {\n nibble[0] = U4::from_u8(input[0] & 0x0f);\n for i in 1..input.len() {\n if i as u32 < length as u32 {\n let x = input[i];\n nibble[2 * i - 1] = U4::from_u8(x >> 4);\n nibble[2 * i] = U4::from_u8(x & 0x0f);\n }\n }\n } else {\n for i in 0..2 {\n if (i as u32) < length as u32 - 1 {\n let x = input[i + 1];\n nibble[2 * i] = U4::from_u8(x >> 4);\n nibble[2 * i + 1] = U4::from_u8(x & 0x0f);\n }\n }\n }\n\n let out = (nibble, 2 * length + (parity as Field) - 2);\n\n out\n}\n\nfn enc(value: [u8; N], value_length: Field) -> ([u8; 32], Field) {\n assert(value.len() as u8 >= value_length as u8);\n let mut out_value = [0; 32];\n if value_length == 0 {\n let out = (out_value, value_length);\n out\n } else if value_length as u8 < 31 {\n out_value[0] = 0x80 + value_length as u8;\n\n for i in 1..value.len() {\n out_value[i] = value[i - 1];\n }\n\n let out = (out_value, value_length + 1);\n\n out\n } else {\n let out = (out_value, 32);\n out\n }\n}\n\nfn bitshift_literal_0() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 0;\n\n bits\n}\nfn bitshift_literal_4() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 4;\n\n bits\n}\nfn bitshift_variable(idx: u8) -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << idx;\n\n bits\n}\n\nfn main(x: [u8; 5], z: Field, u: i16, v: i16) {\n //Issue 1144\n let (nib, len) = compact_decode(x, z);\n assert(len == 5);\n assert(\n [nib[0], nib[1], nib[2], nib[3], nib[4]]\n == [U4::from_u8(15), U4::from_u8(1), U4::from_u8(12), U4::from_u8(11), U4::from_u8(8)],\n );\n // Issue 1169\n let val1 = [\n 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41, 0x12, 0x13,\n 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00,\n ];\n let val1_length = 20;\n\n let enc_val1 = enc(val1, val1_length);\n\n assert(\n enc_val1.0\n == [\n 0x94, 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41,\n 0x12, 0x13, 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00,\n ],\n );\n assert(enc_val1.1 == 21);\n // Issue 2399\n let result_0 = bitshift_literal_0();\n assert(result_0 == 1);\n let result_4 = bitshift_literal_4();\n assert(result_4 == 16);\n let result_0 = bitshift_variable(0);\n assert(result_0 == 1);\n let result_4 = bitshift_variable(4);\n assert(result_4 == 16);\n\n // Issue 6609\n assert(u % -13 == 0);\n assert(u % v == 0);\n assert(u % -11 == 4);\n assert(-u % -11 == -4);\n assert(u % -11 == u % (v + 2));\n assert(-u % -11 == -u % (v + 2));\n}\n", + "source": "global NIBBLE_LENGTH: u32 = 16;\n\nstruct U4 {\n inner: u8,\n}\n\nimpl U4 {\n fn zero() -> U4 {\n U4 { inner: 0 }\n }\n\n fn from_u8(x: u8) -> U4 {\n U4 { inner: x % 16 }\n }\n}\n\nimpl Eq for U4 {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nfn compact_decode(input: [u8; N], length: Field) -> ([U4; NIBBLE_LENGTH], Field) {\n assert(2 * input.len() <= NIBBLE_LENGTH);\n assert(length as u32 <= input.len());\n\n let mut nibble = [U4::zero(); NIBBLE_LENGTH];\n\n let first_nibble = U4::from_u8(input[0] >> 4);\n let parity = first_nibble.inner as u1;\n\n if parity == 1 {\n nibble[0] = U4::from_u8(input[0] & 0x0f);\n for i in 1..input.len() {\n if i as u32 < length as u32 {\n let x = input[i];\n nibble[2 * i - 1] = U4::from_u8(x >> 4);\n nibble[2 * i] = U4::from_u8(x & 0x0f);\n }\n }\n } else {\n for i in 0..2 {\n if (i as u32) < length as u32 - 1 {\n let x = input[i + 1];\n nibble[2 * i] = U4::from_u8(x >> 4);\n nibble[2 * i + 1] = U4::from_u8(x & 0x0f);\n }\n }\n }\n\n let out = (nibble, 2 * length + (parity as Field) - 2);\n\n out\n}\n\nfn enc(value: [u8; N], value_length: Field) -> ([u8; 32], Field) {\n assert(value.len() as u8 >= value_length as u8);\n let mut out_value = [0; 32];\n if value_length == 0 {\n let out = (out_value, value_length);\n out\n } else if value_length as u8 < 31 {\n out_value[0] = 0x80 + value_length as u8;\n\n for i in 1..value.len() {\n out_value[i] = value[i - 1];\n }\n\n let out = (out_value, value_length + 1);\n\n out\n } else {\n let out = (out_value, 32);\n out\n }\n}\n\nfn bitshift_literal_0() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 0;\n\n bits\n}\nfn bitshift_literal_4() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 4;\n\n bits\n}\nfn bitshift_variable(idx: u64) -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << idx;\n\n bits\n}\n\nfn main(x: [u8; 5], z: Field, u: i16, v: i16) {\n //Issue 1144\n let (nib, len) = compact_decode(x, z);\n assert(len == 5);\n assert(\n [nib[0], nib[1], nib[2], nib[3], nib[4]]\n == [U4::from_u8(15), U4::from_u8(1), U4::from_u8(12), U4::from_u8(11), U4::from_u8(8)],\n );\n // Issue 1169\n let val1 = [\n 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41, 0x12, 0x13,\n 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00,\n ];\n let val1_length = 20;\n\n let enc_val1 = enc(val1, val1_length);\n\n assert(\n enc_val1.0\n == [\n 0x94, 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41,\n 0x12, 0x13, 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00,\n ],\n );\n assert(enc_val1.1 == 21);\n // Issue 2399\n let result_0 = bitshift_literal_0();\n assert(result_0 == 1);\n let result_4 = bitshift_literal_4();\n assert(result_4 == 16);\n let result_0 = bitshift_variable(0);\n assert(result_0 == 1);\n let result_4 = bitshift_variable(4);\n assert(result_4 == 16);\n\n // Issue 6609\n assert(u % -13 == 0);\n assert(u % v == 0);\n assert(u % -11 == 4);\n assert(-u % -11 == -4);\n assert(u % -11 == u % (v + 2));\n assert(-u % -11 == -u % (v + 2));\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index b9bc31af6f4..6e44482c36d 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -80,14 +80,14 @@ expression: artifact "unconstrained func 0", "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32853 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 8 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32845), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U16) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U16) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32845 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 33 }, Mov { destination: Relative(1), source: Relative(5) }, Mov { destination: Relative(2), source: Direct(32850) }, Mov { destination: Relative(3), source: Direct(32851) }, Mov { destination: Relative(4), source: Direct(32852) }, Call { location: 44 }, Call { location: 55 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32853 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 43 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 36 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 16 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 0 }, Const { destination: Direct(32837), bit_size: Integer(U8), value: 0 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32839), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32841), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32842), bit_size: Integer(U32), value: 5 }, Const { destination: Direct(32843), bit_size: Integer(U32), value: 32 }, Const { destination: Direct(32844), bit_size: Integer(U8), value: 128 }, Return, Call { location: 540 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Relative(1) }, Mov { destination: Relative(10), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 546 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(5), source: Relative(9) }, Mov { destination: Relative(6), source: Relative(10) }, Const { destination: Relative(1), bit_size: Field, value: 5 }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 70 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32840) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32841) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Load { destination: Relative(7), source_pointer: Relative(8) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32842) }, Load { destination: Relative(6), source_pointer: Relative(9) }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(10), source: Relative(9) }, Store { destination_pointer: Relative(10), source: Relative(1) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(8) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 15 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 12 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 11 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 8 }, Mov { destination: Relative(9), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(9), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Mov { destination: Relative(11), source: Relative(10) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(6) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(7) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(5) }, Mov { destination: Relative(12), source: Relative(9) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(2) }, Call { location: 745 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(11) }, JumpIf { condition: Relative(1), location: 128 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 184 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 143 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 97 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 230 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 251 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 218 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 131 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 255 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 250 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 190 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 54 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 65 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 18 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 19 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 57 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 24 }, Mov { destination: Relative(20), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Mov { destination: Relative(22), source: Relative(21) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(5) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(6) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(7) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(8) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(9) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(7) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(10) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(12) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(13) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(14) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(15) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(16) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(17) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Direct(32844) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(18) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Direct(32844) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Direct(32837) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Direct(32837) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Direct(32837) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Direct(32837) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Direct(32837) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Direct(32837) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Direct(32837) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Direct(32837) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Direct(32837) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Direct(32837) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Direct(32837) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Direct(32837) }, Const { destination: Relative(21), bit_size: Field, value: 20 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 25 }, Mov { destination: Relative(25), source: Direct(0) }, Mov { destination: Relative(26), source: Relative(20) }, Mov { destination: Relative(27), source: Relative(21) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(24) }, Call { location: 769 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(22), source: Relative(26) }, Mov { destination: Relative(23), source: Relative(27) }, Load { destination: Relative(20), source_pointer: Relative(22) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 230 }, Call { location: 921 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(20) }, Const { destination: Relative(20), bit_size: Integer(U8), value: 148 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(25) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(26), source: Relative(25) }, Store { destination_pointer: Relative(26), source: Relative(20) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(1) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(5) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(6) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(7) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(9) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(7) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(11) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(14) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(15) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(16) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(17) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Direct(32844) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(18) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Direct(32844) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(19) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Direct(32837) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Direct(32837) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Direct(32837) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Direct(32837) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Direct(32837) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Direct(32837) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Direct(32837) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Direct(32837) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Direct(32837) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Direct(32837) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Direct(32837) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 25 }, Mov { destination: Relative(25), source: Direct(0) }, Mov { destination: Relative(26), source: Relative(22) }, Mov { destination: Relative(27), source: Relative(24) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(2) }, Call { location: 924 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(26) }, JumpIf { condition: Relative(1), location: 313 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Const { destination: Relative(1), bit_size: Field, value: 21 }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(23), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 318 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U16), value: 65523 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(3) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 325 }, Jump { location: 327 }, Mov { destination: Relative(8), source: Relative(14) }, Jump { location: 329 }, Mov { destination: Relative(8), source: Relative(3) }, Jump { location: 329 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(1) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(1) }, JumpIf { condition: Relative(9), location: 335 }, Jump { location: 337 }, Mov { destination: Relative(10), source: Relative(14) }, Jump { location: 339 }, Mov { destination: Relative(10), source: Relative(1) }, Jump { location: 339 }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U16, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Xor, bit_size: U1, lhs: Relative(7), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 343 }, Jump { location: 345 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U16, lhs: Relative(12), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U16, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(3), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 352 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(3) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 358 }, Jump { location: 360 }, Mov { destination: Relative(8), source: Relative(14) }, Jump { location: 362 }, Mov { destination: Relative(8), source: Relative(3) }, Jump { location: 362 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(4) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 368 }, Jump { location: 370 }, Mov { destination: Relative(10), source: Relative(14) }, Jump { location: 372 }, Mov { destination: Relative(10), source: Relative(4) }, Jump { location: 372 }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U16, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Xor, bit_size: U1, lhs: Relative(7), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 376 }, Jump { location: 378 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U16, lhs: Relative(12), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U16, lhs: Relative(5), rhs: Relative(4) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(3), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 384 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65525 }, Const { destination: Relative(13), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U16, lhs: Relative(13), rhs: Relative(3) }, Const { destination: Relative(14), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U16, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(8), location: 391 }, Jump { location: 393 }, Mov { destination: Relative(9), source: Relative(15) }, Jump { location: 395 }, Mov { destination: Relative(9), source: Relative(3) }, Jump { location: 395 }, Const { destination: Relative(13), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U16, lhs: Relative(13), rhs: Relative(2) }, Const { destination: Relative(14), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U16, lhs: Relative(14), rhs: Relative(2) }, JumpIf { condition: Relative(10), location: 401 }, Jump { location: 403 }, Mov { destination: Relative(11), source: Relative(15) }, Jump { location: 405 }, Mov { destination: Relative(11), source: Relative(2) }, Jump { location: 405 }, BinaryIntOp { destination: Relative(6), op: Div, bit_size: U16, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(12), op: Xor, bit_size: U1, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(12), location: 409 }, Jump { location: 411 }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(6) }, BinaryIntOp { destination: Relative(7), op: Mul, bit_size: U16, lhs: Relative(6), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U16, lhs: Relative(3), rhs: Relative(7) }, Const { destination: Relative(6), bit_size: Integer(U16), value: 4 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U16, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 418 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U16, lhs: Relative(1), rhs: Relative(3) }, Mov { destination: Relative(1), source: Relative(5) }, Cast { destination: Relative(5), source: Relative(1), bit_size: Integer(U16) }, Cast { destination: Relative(7), source: Relative(3), bit_size: Integer(U16) }, Const { destination: Relative(8), bit_size: Integer(U16), value: 32768 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(7), rhs: Relative(8) }, Not { destination: Relative(7), source: Relative(9), bit_size: U1 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(5), rhs: Relative(8) }, BinaryIntOp { destination: Relative(5), op: Mul, bit_size: U1, lhs: Relative(9), rhs: Relative(7) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(5), rhs: Relative(7) }, JumpIf { condition: Relative(9), location: 430 }, Call { location: 948 }, Const { destination: Relative(15), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U16, lhs: Relative(15), rhs: Relative(1) }, Const { destination: Relative(16), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(17), op: Sub, bit_size: U16, lhs: Relative(16), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 436 }, Jump { location: 438 }, Mov { destination: Relative(11), source: Relative(17) }, Jump { location: 440 }, Mov { destination: Relative(11), source: Relative(1) }, Jump { location: 440 }, Const { destination: Relative(15), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U16, lhs: Relative(15), rhs: Relative(2) }, Const { destination: Relative(16), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(17), op: Sub, bit_size: U16, lhs: Relative(16), rhs: Relative(2) }, JumpIf { condition: Relative(12), location: 446 }, Jump { location: 448 }, Mov { destination: Relative(13), source: Relative(17) }, Jump { location: 450 }, Mov { destination: Relative(13), source: Relative(2) }, Jump { location: 450 }, BinaryIntOp { destination: Relative(7), op: Div, bit_size: U16, lhs: Relative(11), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: Xor, bit_size: U1, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 454 }, Jump { location: 456 }, Const { destination: Relative(15), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(7), op: Sub, bit_size: U16, lhs: Relative(15), rhs: Relative(7) }, BinaryIntOp { destination: Relative(9), op: Mul, bit_size: U16, lhs: Relative(7), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U16, lhs: Relative(1), rhs: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65532 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U16, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 463 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Const { destination: Relative(5), bit_size: Integer(U16), value: 2 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U16, lhs: Relative(4), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(7) }, Cast { destination: Relative(7), source: Relative(5), bit_size: Integer(U16) }, Cast { destination: Relative(9), source: Relative(4), bit_size: Integer(U16) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U16, lhs: Relative(9), rhs: Relative(8) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(7), rhs: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(4) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(7), rhs: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 475 }, Call { location: 951 }, Const { destination: Relative(14), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(14), rhs: Relative(3) }, Const { destination: Relative(15), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U16, lhs: Relative(15), rhs: Relative(3) }, JumpIf { condition: Relative(9), location: 481 }, Jump { location: 483 }, Mov { destination: Relative(10), source: Relative(16) }, Jump { location: 485 }, Mov { destination: Relative(10), source: Relative(3) }, Jump { location: 485 }, Const { destination: Relative(14), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U16, lhs: Relative(14), rhs: Relative(5) }, Const { destination: Relative(15), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U16, lhs: Relative(15), rhs: Relative(5) }, JumpIf { condition: Relative(11), location: 491 }, Jump { location: 493 }, Mov { destination: Relative(12), source: Relative(16) }, Jump { location: 495 }, Mov { destination: Relative(12), source: Relative(5) }, Jump { location: 495 }, BinaryIntOp { destination: Relative(7), op: Div, bit_size: U16, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: Xor, bit_size: U1, lhs: Relative(9), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 499 }, Jump { location: 501 }, Const { destination: Relative(14), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(7), op: Sub, bit_size: U16, lhs: Relative(14), rhs: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U16, lhs: Relative(7), rhs: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(3), rhs: Relative(8) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(6), rhs: Relative(4) }, JumpIf { condition: Relative(3), location: 507 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(1) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 513 }, Jump { location: 515 }, Mov { destination: Relative(8), source: Relative(14) }, Jump { location: 517 }, Mov { destination: Relative(8), source: Relative(1) }, Jump { location: 517 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(5) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(5) }, JumpIf { condition: Relative(9), location: 523 }, Jump { location: 525 }, Mov { destination: Relative(10), source: Relative(14) }, Jump { location: 527 }, Mov { destination: Relative(10), source: Relative(5) }, Jump { location: 527 }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U16, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Xor, bit_size: U1, lhs: Relative(7), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 531 }, Jump { location: 533 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(12), rhs: Relative(4) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U16, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U16, lhs: Relative(1), rhs: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(1), location: 539 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 545 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 540 }, Cast { destination: Relative(4), source: Relative(2), bit_size: Integer(U32) }, Cast { destination: Relative(3), source: Relative(4), bit_size: Field }, Cast { destination: Relative(4), source: Relative(3), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32842), rhs: Relative(4) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Direct(32836) }, JumpIf { condition: Relative(5), location: 555 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 16 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Mov { destination: Relative(7), source: Relative(5) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 569 }, Store { destination_pointer: Relative(7), source: Direct(32837) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Jump { location: 563 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32840) }, Load { destination: Relative(3), source_pointer: Relative(6) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 4 }, BinaryIntOp { destination: Relative(7), op: Shr, bit_size: U8, lhs: Relative(3), rhs: Relative(6) }, Const { destination: Relative(9), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(10), op: Div, bit_size: U8, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(11), op: Mul, bit_size: U8, lhs: Relative(10), rhs: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U8, lhs: Relative(7), rhs: Relative(11) }, Cast { destination: Relative(9), source: Relative(8), bit_size: Integer(U1) }, Cast { destination: Relative(7), source: Relative(9), bit_size: Integer(U8) }, Cast { destination: Relative(8), source: Relative(7), bit_size: Integer(U1) }, JumpIf { condition: Relative(8), location: 644 }, Jump { location: 585 }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Direct(32840) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Direct(32840), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 589 }, Call { location: 948 }, Mov { destination: Relative(3), source: Direct(32838) }, Jump { location: 591 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32841) }, JumpIf { condition: Relative(4), location: 595 }, Jump { location: 594 }, Jump { location: 692 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32840) }, JumpIf { condition: Relative(4), location: 599 }, Jump { location: 642 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Direct(32842) }, JumpIf { condition: Relative(4), location: 602 }, Call { location: 954 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Load { destination: Relative(4), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U32, lhs: Direct(32841), rhs: Relative(3) }, BinaryIntOp { destination: Relative(11), op: Shr, bit_size: U8, lhs: Relative(4), rhs: Relative(6) }, Const { destination: Relative(13), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(14), op: Div, bit_size: U8, lhs: Relative(11), rhs: Relative(13) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U8, lhs: Relative(14), rhs: Relative(13) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U8, lhs: Relative(11), rhs: Relative(15) }, Load { destination: Relative(11), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Direct(32835) }, JumpIf { condition: Relative(13), location: 615 }, Call { location: 954 }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 17 }, Call { location: 957 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Store { destination_pointer: Relative(15), source: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(32840) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(10), rhs: Relative(11) }, JumpIf { condition: Relative(12), location: 626 }, Call { location: 951 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(14), op: Div, bit_size: U8, lhs: Relative(4), rhs: Relative(12) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U8, lhs: Relative(14), rhs: Relative(12) }, BinaryIntOp { destination: Relative(10), op: Sub, bit_size: U8, lhs: Relative(4), rhs: Relative(15) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 633 }, Call { location: 954 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 17 }, Call { location: 957 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Store { destination_pointer: Relative(14), source: Relative(10) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Jump { location: 642 }, Mov { destination: Relative(3), source: Relative(9) }, Jump { location: 591 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(11), op: Div, bit_size: U8, lhs: Relative(3), rhs: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Mul, bit_size: U8, lhs: Relative(11), rhs: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Sub, bit_size: U8, lhs: Relative(3), rhs: Relative(12) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(11), source: Relative(10) }, Store { destination_pointer: Relative(11), source: Relative(9) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Direct(32837) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Direct(32837) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Direct(32837) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Direct(32837) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Direct(32837) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Direct(32837) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Direct(32837) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Direct(32837) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Direct(32837) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Direct(32837) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Direct(32837) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Direct(32837) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Direct(32837) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Direct(32837) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Direct(32837) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Mov { destination: Relative(8), source: Direct(32840) }, Jump { location: 688 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32842) }, JumpIf { condition: Relative(3), location: 699 }, Jump { location: 691 }, Jump { location: 692 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Const { destination: Relative(3), bit_size: Field, value: 2 }, BinaryFieldOp { destination: Relative(4), op: Mul, lhs: Relative(3), rhs: Relative(2) }, Cast { destination: Relative(2), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(5), op: Add, lhs: Relative(4), rhs: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Sub, lhs: Relative(5), rhs: Relative(3) }, Return, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(3), location: 702 }, Jump { location: 742 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Mul, bit_size: U32, lhs: Direct(32841), rhs: Relative(8) }, BinaryIntOp { destination: Relative(10), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Direct(32840) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U32, lhs: Direct(32840), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 710 }, Call { location: 948 }, BinaryIntOp { destination: Relative(11), op: Shr, bit_size: U8, lhs: Relative(3), rhs: Relative(6) }, Const { destination: Relative(13), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(14), op: Div, bit_size: U8, lhs: Relative(11), rhs: Relative(13) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U8, lhs: Relative(14), rhs: Relative(13) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U8, lhs: Relative(11), rhs: Relative(15) }, Load { destination: Relative(11), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Direct(32835) }, JumpIf { condition: Relative(13), location: 719 }, Call { location: 954 }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 17 }, Call { location: 957 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(10) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Const { destination: Relative(11), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(12), op: Div, bit_size: U8, lhs: Relative(3), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: Mul, bit_size: U8, lhs: Relative(12), rhs: Relative(11) }, BinaryIntOp { destination: Relative(10), op: Sub, bit_size: U8, lhs: Relative(3), rhs: Relative(14) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 733 }, Call { location: 954 }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 17 }, Call { location: 957 }, Mov { destination: Relative(3), source: Direct(32773) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(9) }, Store { destination_pointer: Relative(12), source: Relative(10) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 742 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32840) }, Mov { destination: Relative(8), source: Relative(3) }, Jump { location: 688 }, Call { location: 540 }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Direct(32839) }, Mov { destination: Relative(3), source: Direct(32838) }, Jump { location: 751 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32842) }, JumpIf { condition: Relative(5), location: 756 }, Jump { location: 754 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(5), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(8) }, Store { destination_pointer: Relative(4), source: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32840) }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 751 }, Call { location: 540 }, Cast { destination: Relative(6), source: Relative(2), bit_size: Integer(U8) }, Cast { destination: Relative(5), source: Relative(6), bit_size: Field }, Cast { destination: Relative(6), source: Relative(5), bit_size: Integer(U8) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 32 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U8, lhs: Relative(5), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Direct(32836) }, JumpIf { condition: Relative(5), location: 779 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 793 }, Store { destination_pointer: Relative(9), source: Direct(32837) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 787 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, Const { destination: Relative(8), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 915 }, Jump { location: 800 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 31 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U8, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(11), location: 808 }, Jump { location: 804 }, Const { destination: Relative(1), bit_size: Field, value: 32 }, Mov { destination: Relative(8), source: Relative(5) }, Mov { destination: Relative(9), source: Relative(1) }, Jump { location: 893 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U8, lhs: Direct(32844), rhs: Relative(6) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U8, lhs: Direct(32844), rhs: Relative(10) }, JumpIf { condition: Relative(11), location: 812 }, Call { location: 951 }, Mov { destination: Relative(6), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Mov { destination: Relative(12), source: Relative(11) }, Store { destination_pointer: Relative(12), source: Relative(10) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, Store { destination_pointer: Relative(7), source: Relative(6) }, Mov { destination: Relative(5), source: Direct(32840) }, Jump { location: 884 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Direct(32843) }, JumpIf { condition: Relative(6), location: 896 }, Jump { location: 887 }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(5), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(6), op: Add, lhs: Relative(2), rhs: Relative(5) }, Mov { destination: Relative(8), source: Relative(1) }, Mov { destination: Relative(9), source: Relative(6) }, Jump { location: 893 }, Mov { destination: Relative(3), source: Relative(8) }, Mov { destination: Relative(4), source: Relative(9) }, Jump { location: 918 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(5), rhs: Direct(32840) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, JumpIf { condition: Relative(10), location: 900 }, Call { location: 954 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, Load { destination: Relative(10), source_pointer: Relative(12) }, Load { destination: Relative(6), source_pointer: Relative(7) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 957 }, Mov { destination: Relative(11), source: Direct(32773) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(5) }, Store { destination_pointer: Relative(13), source: Relative(10) }, Store { destination_pointer: Relative(7), source: Relative(11) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32840) }, Mov { destination: Relative(5), source: Relative(6) }, Jump { location: 884 }, Mov { destination: Relative(3), source: Relative(5) }, Mov { destination: Relative(4), source: Relative(2) }, Jump { location: 918 }, Mov { destination: Relative(1), source: Relative(3) }, Mov { destination: Relative(2), source: Relative(4) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 540 }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Direct(32839) }, Mov { destination: Relative(3), source: Direct(32838) }, Jump { location: 930 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32843) }, JumpIf { condition: Relative(5), location: 935 }, Jump { location: 933 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(5), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(8) }, Store { destination_pointer: Relative(4), source: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32840) }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 930 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 961 }, Jump { location: 963 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 978 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 975 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 968 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 978 }, Return]" ], - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n if result {\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use super::{Eq, max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0_u64, 1), 0);\n assert_eq(min(0_u64, 0), 0);\n assert_eq(min(1_u64, 1), 1);\n assert_eq(min(255_u8, 0), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0_u64, 1), 1);\n assert_eq(max(0_u64, 0), 0);\n assert_eq(max(1_u64, 1), 1);\n assert_eq(max(255_u8, 0), 255);\n }\n\n #[test]\n fn correctly_handles_unequal_length_slices() {\n let slice_1 = &[0, 1, 2, 3];\n let slice_2 = &[0, 1, 2];\n assert(!slice_1.eq(slice_2));\n }\n}\n", "path": "std/cmp.nr" }, "50": { - "source": "global NIBBLE_LENGTH: u32 = 16;\n\nstruct U4 {\n inner: u8,\n}\n\nimpl U4 {\n fn zero() -> U4 {\n U4 { inner: 0 }\n }\n\n fn from_u8(x: u8) -> U4 {\n U4 { inner: x % 16 }\n }\n}\n\nimpl Eq for U4 {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nfn compact_decode(input: [u8; N], length: Field) -> ([U4; NIBBLE_LENGTH], Field) {\n assert(2 * input.len() <= NIBBLE_LENGTH);\n assert(length as u32 <= input.len());\n\n let mut nibble = [U4::zero(); NIBBLE_LENGTH];\n\n let first_nibble = U4::from_u8(input[0] >> 4);\n let parity = first_nibble.inner as u1;\n\n if parity == 1 {\n nibble[0] = U4::from_u8(input[0] & 0x0f);\n for i in 1..input.len() {\n if i as u32 < length as u32 {\n let x = input[i];\n nibble[2 * i - 1] = U4::from_u8(x >> 4);\n nibble[2 * i] = U4::from_u8(x & 0x0f);\n }\n }\n } else {\n for i in 0..2 {\n if (i as u32) < length as u32 - 1 {\n let x = input[i + 1];\n nibble[2 * i] = U4::from_u8(x >> 4);\n nibble[2 * i + 1] = U4::from_u8(x & 0x0f);\n }\n }\n }\n\n let out = (nibble, 2 * length + (parity as Field) - 2);\n\n out\n}\n\nfn enc(value: [u8; N], value_length: Field) -> ([u8; 32], Field) {\n assert(value.len() as u8 >= value_length as u8);\n let mut out_value = [0; 32];\n if value_length == 0 {\n let out = (out_value, value_length);\n out\n } else if value_length as u8 < 31 {\n out_value[0] = 0x80 + value_length as u8;\n\n for i in 1..value.len() {\n out_value[i] = value[i - 1];\n }\n\n let out = (out_value, value_length + 1);\n\n out\n } else {\n let out = (out_value, 32);\n out\n }\n}\n\nfn bitshift_literal_0() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 0;\n\n bits\n}\nfn bitshift_literal_4() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 4;\n\n bits\n}\nfn bitshift_variable(idx: u8) -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << idx;\n\n bits\n}\n\nfn main(x: [u8; 5], z: Field, u: i16, v: i16) {\n //Issue 1144\n let (nib, len) = compact_decode(x, z);\n assert(len == 5);\n assert(\n [nib[0], nib[1], nib[2], nib[3], nib[4]]\n == [U4::from_u8(15), U4::from_u8(1), U4::from_u8(12), U4::from_u8(11), U4::from_u8(8)],\n );\n // Issue 1169\n let val1 = [\n 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41, 0x12, 0x13,\n 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00,\n ];\n let val1_length = 20;\n\n let enc_val1 = enc(val1, val1_length);\n\n assert(\n enc_val1.0\n == [\n 0x94, 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41,\n 0x12, 0x13, 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00,\n ],\n );\n assert(enc_val1.1 == 21);\n // Issue 2399\n let result_0 = bitshift_literal_0();\n assert(result_0 == 1);\n let result_4 = bitshift_literal_4();\n assert(result_4 == 16);\n let result_0 = bitshift_variable(0);\n assert(result_0 == 1);\n let result_4 = bitshift_variable(4);\n assert(result_4 == 16);\n\n // Issue 6609\n assert(u % -13 == 0);\n assert(u % v == 0);\n assert(u % -11 == 4);\n assert(-u % -11 == -4);\n assert(u % -11 == u % (v + 2));\n assert(-u % -11 == -u % (v + 2));\n}\n", + "source": "global NIBBLE_LENGTH: u32 = 16;\n\nstruct U4 {\n inner: u8,\n}\n\nimpl U4 {\n fn zero() -> U4 {\n U4 { inner: 0 }\n }\n\n fn from_u8(x: u8) -> U4 {\n U4 { inner: x % 16 }\n }\n}\n\nimpl Eq for U4 {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nfn compact_decode(input: [u8; N], length: Field) -> ([U4; NIBBLE_LENGTH], Field) {\n assert(2 * input.len() <= NIBBLE_LENGTH);\n assert(length as u32 <= input.len());\n\n let mut nibble = [U4::zero(); NIBBLE_LENGTH];\n\n let first_nibble = U4::from_u8(input[0] >> 4);\n let parity = first_nibble.inner as u1;\n\n if parity == 1 {\n nibble[0] = U4::from_u8(input[0] & 0x0f);\n for i in 1..input.len() {\n if i as u32 < length as u32 {\n let x = input[i];\n nibble[2 * i - 1] = U4::from_u8(x >> 4);\n nibble[2 * i] = U4::from_u8(x & 0x0f);\n }\n }\n } else {\n for i in 0..2 {\n if (i as u32) < length as u32 - 1 {\n let x = input[i + 1];\n nibble[2 * i] = U4::from_u8(x >> 4);\n nibble[2 * i + 1] = U4::from_u8(x & 0x0f);\n }\n }\n }\n\n let out = (nibble, 2 * length + (parity as Field) - 2);\n\n out\n}\n\nfn enc(value: [u8; N], value_length: Field) -> ([u8; 32], Field) {\n assert(value.len() as u8 >= value_length as u8);\n let mut out_value = [0; 32];\n if value_length == 0 {\n let out = (out_value, value_length);\n out\n } else if value_length as u8 < 31 {\n out_value[0] = 0x80 + value_length as u8;\n\n for i in 1..value.len() {\n out_value[i] = value[i - 1];\n }\n\n let out = (out_value, value_length + 1);\n\n out\n } else {\n let out = (out_value, 32);\n out\n }\n}\n\nfn bitshift_literal_0() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 0;\n\n bits\n}\nfn bitshift_literal_4() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 4;\n\n bits\n}\nfn bitshift_variable(idx: u64) -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << idx;\n\n bits\n}\n\nfn main(x: [u8; 5], z: Field, u: i16, v: i16) {\n //Issue 1144\n let (nib, len) = compact_decode(x, z);\n assert(len == 5);\n assert(\n [nib[0], nib[1], nib[2], nib[3], nib[4]]\n == [U4::from_u8(15), U4::from_u8(1), U4::from_u8(12), U4::from_u8(11), U4::from_u8(8)],\n );\n // Issue 1169\n let val1 = [\n 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41, 0x12, 0x13,\n 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00,\n ];\n let val1_length = 20;\n\n let enc_val1 = enc(val1, val1_length);\n\n assert(\n enc_val1.0\n == [\n 0x94, 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41,\n 0x12, 0x13, 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00,\n ],\n );\n assert(enc_val1.1 == 21);\n // Issue 2399\n let result_0 = bitshift_literal_0();\n assert(result_0 == 1);\n let result_4 = bitshift_literal_4();\n assert(result_4 == 16);\n let result_0 = bitshift_variable(0);\n assert(result_0 == 1);\n let result_4 = bitshift_variable(4);\n assert(result_4 == 16);\n\n // Issue 6609\n assert(u % -13 == 0);\n assert(u % v == 0);\n assert(u % -11 == 4);\n assert(-u % -11 == -4);\n assert(u % -11 == u % (v + 2));\n assert(-u % -11 == -u % (v + 2));\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_true_inliner_0.snap index cd141b65bc3..482f3ab425e 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_true_inliner_0.snap @@ -80,14 +80,14 @@ expression: artifact "unconstrained func 0", "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32844 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 8 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U8) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U8) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U8) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U16) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U16) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32836 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 33 }, Mov { destination: Relative(1), source: Relative(5) }, Mov { destination: Relative(2), source: Direct(32841) }, Mov { destination: Relative(3), source: Direct(32842) }, Mov { destination: Relative(4), source: Direct(32843) }, Call { location: 44 }, Call { location: 46 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 43 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 36 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 16 }, Return, Call { location: 838 }, Cast { destination: Relative(6), source: Relative(2), bit_size: Integer(U32) }, Cast { destination: Relative(5), source: Relative(6), bit_size: Field }, Cast { destination: Relative(6), source: Relative(5), bit_size: Integer(U32) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Const { destination: Relative(8), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 57 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Const { destination: Relative(7), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 16 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Mov { destination: Relative(11), source: Relative(9) }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 72 }, Store { destination_pointer: Relative(11), source: Relative(7) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Jump { location: 66 }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Load { destination: Relative(10), source_pointer: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U8), value: 4 }, BinaryIntOp { destination: Relative(12), op: Shr, bit_size: U8, lhs: Relative(10), rhs: Relative(11) }, Const { destination: Relative(14), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(15), op: Div, bit_size: U8, lhs: Relative(12), rhs: Relative(14) }, BinaryIntOp { destination: Relative(16), op: Mul, bit_size: U8, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Sub, bit_size: U8, lhs: Relative(12), rhs: Relative(16) }, Cast { destination: Relative(14), source: Relative(13), bit_size: Integer(U1) }, Cast { destination: Relative(12), source: Relative(14), bit_size: Integer(U8) }, Cast { destination: Relative(13), source: Relative(12), bit_size: Integer(U1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(16), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 151 }, Jump { location: 92 }, BinaryIntOp { destination: Relative(13), op: Sub, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(6) }, JumpIf { condition: Relative(17), location: 96 }, Call { location: 844 }, Mov { destination: Relative(10), source: Relative(14) }, Jump { location: 98 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(6), location: 102 }, Jump { location: 101 }, Jump { location: 199 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(13) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(8) }, JumpIf { condition: Relative(6), location: 106 }, Jump { location: 149 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 109 }, Call { location: 847 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(17) }, Load { destination: Relative(6), source_pointer: Relative(19) }, BinaryIntOp { destination: Relative(18), op: Mul, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, BinaryIntOp { destination: Relative(19), op: Shr, bit_size: U8, lhs: Relative(6), rhs: Relative(11) }, Const { destination: Relative(21), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(22), op: Div, bit_size: U8, lhs: Relative(19), rhs: Relative(21) }, BinaryIntOp { destination: Relative(23), op: Mul, bit_size: U8, lhs: Relative(22), rhs: Relative(21) }, BinaryIntOp { destination: Relative(20), op: Sub, bit_size: U8, lhs: Relative(19), rhs: Relative(23) }, Load { destination: Relative(19), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Direct(32835) }, JumpIf { condition: Relative(21), location: 122 }, Call { location: 847 }, Mov { destination: Direct(32771), source: Relative(19) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 17 }, Call { location: 850 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Store { destination_pointer: Relative(23), source: Relative(20) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(8) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(18), rhs: Relative(19) }, JumpIf { condition: Relative(20), location: 133 }, Call { location: 872 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(22), op: Div, bit_size: U8, lhs: Relative(6), rhs: Relative(20) }, BinaryIntOp { destination: Relative(23), op: Mul, bit_size: U8, lhs: Relative(22), rhs: Relative(20) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U8, lhs: Relative(6), rhs: Relative(23) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(19), rhs: Direct(32835) }, JumpIf { condition: Relative(6), location: 140 }, Call { location: 847 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 17 }, Call { location: 850 }, Mov { destination: Relative(6), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(18) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Jump { location: 149 }, Mov { destination: Relative(10), source: Relative(17) }, Jump { location: 98 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(19), op: Div, bit_size: U8, lhs: Relative(10), rhs: Relative(18) }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U8, lhs: Relative(19), rhs: Relative(18) }, BinaryIntOp { destination: Relative(17), op: Sub, bit_size: U8, lhs: Relative(10), rhs: Relative(20) }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(18) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Relative(19), source: Relative(18) }, Store { destination_pointer: Relative(19), source: Relative(17) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, Store { destination_pointer: Relative(9), source: Relative(10) }, Mov { destination: Relative(13), source: Relative(8) }, Jump { location: 195 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(5) }, JumpIf { condition: Relative(10), location: 792 }, Jump { location: 198 }, Jump { location: 199 }, Load { destination: Relative(6), source_pointer: Relative(9) }, Const { destination: Relative(9), bit_size: Field, value: 2 }, BinaryFieldOp { destination: Relative(10), op: Mul, lhs: Relative(9), rhs: Relative(2) }, Cast { destination: Relative(2), source: Relative(12), bit_size: Field }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(10), rhs: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Sub, lhs: Relative(11), rhs: Relative(9) }, Const { destination: Relative(9), bit_size: Field, value: 5 }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(2), rhs: Relative(9) }, JumpIf { condition: Relative(10), location: 210 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(15) }, Load { destination: Relative(9), source_pointer: Relative(10) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(12) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(13) }, Mov { destination: Relative(6), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(13) }, Store { destination_pointer: Relative(15), source: Relative(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(11) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(12) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(10) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 15 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 12 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 11 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 8 }, Mov { destination: Relative(13), source: Direct(1) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(15) }, IndirectConst { destination_pointer: Relative(13), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Mov { destination: Relative(17), source: Relative(15) }, Store { destination_pointer: Relative(17), source: Relative(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(9) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(10) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(11) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(12) }, Mov { destination: Relative(2), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(16) }, Mov { destination: Relative(1), source: Relative(14) }, Jump { location: 262 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(9), location: 779 }, Jump { location: 265 }, Load { destination: Relative(5), source_pointer: Relative(2) }, JumpIf { condition: Relative(5), location: 269 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Const { destination: Relative(2), bit_size: Integer(U8), value: 184 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 143 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 97 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 230 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 251 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 218 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 131 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 255 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 250 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 190 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 54 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 65 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 18 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 19 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 128 }, Const { destination: Relative(24), bit_size: Integer(U8), value: 57 }, Const { destination: Relative(25), bit_size: Integer(U8), value: 24 }, Mov { destination: Relative(26), source: Direct(1) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(27) }, IndirectConst { destination_pointer: Relative(26), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Mov { destination: Relative(28), source: Relative(27) }, Store { destination_pointer: Relative(28), source: Relative(2) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(5) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(6) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(9) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(10) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(12) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(10) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(13) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(15) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(17) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(18) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(19) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(20) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(21) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(22) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(23) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(24) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(23) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(25) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(28), bit_size: Integer(U8), value: 148 }, Mov { destination: Relative(29), source: Direct(1) }, Const { destination: Relative(30), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(30) }, IndirectConst { destination_pointer: Relative(29), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Mov { destination: Relative(31), source: Relative(30) }, Store { destination_pointer: Relative(31), source: Relative(28) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, Store { destination_pointer: Relative(27), source: Relative(29) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 432 }, BinaryIntOp { destination: Relative(30), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(29) }, JumpIf { condition: Relative(30), location: 760 }, Jump { location: 435 }, Load { destination: Relative(26), source_pointer: Relative(27) }, Load { destination: Relative(27), source_pointer: Relative(26) }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(31), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(27) }, Not { destination: Relative(31), source: Relative(31), bit_size: U1 }, JumpIf { condition: Relative(31), location: 442 }, Call { location: 875 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Mov { destination: Relative(27), source: Direct(1) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(31) }, IndirectConst { destination_pointer: Relative(27), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Mov { destination: Relative(32), source: Relative(31) }, Store { destination_pointer: Relative(32), source: Relative(28) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(2) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(5) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(6) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(9) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(10) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(11) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(12) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(10) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(13) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(15) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(17) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(18) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(19) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(21) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(22) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(23) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(24) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(23) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(25) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, Mov { destination: Relative(2), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(16) }, Mov { destination: Relative(1), source: Relative(14) }, Jump { location: 518 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(29) }, JumpIf { condition: Relative(5), location: 747 }, Jump { location: 521 }, Load { destination: Relative(1), source_pointer: Relative(2) }, JumpIf { condition: Relative(1), location: 525 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Const { destination: Relative(1), bit_size: Integer(U16), value: 65523 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(3) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 532 }, Jump { location: 534 }, Mov { destination: Relative(8), source: Relative(14) }, Jump { location: 536 }, Mov { destination: Relative(8), source: Relative(3) }, Jump { location: 536 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(1) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(1) }, JumpIf { condition: Relative(9), location: 542 }, Jump { location: 544 }, Mov { destination: Relative(10), source: Relative(14) }, Jump { location: 546 }, Mov { destination: Relative(10), source: Relative(1) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U16, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Xor, bit_size: U1, lhs: Relative(7), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 550 }, Jump { location: 552 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U16, lhs: Relative(12), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U16, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(3), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 559 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(3) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 565 }, Jump { location: 567 }, Mov { destination: Relative(8), source: Relative(14) }, Jump { location: 569 }, Mov { destination: Relative(8), source: Relative(3) }, Jump { location: 569 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(4) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 575 }, Jump { location: 577 }, Mov { destination: Relative(10), source: Relative(14) }, Jump { location: 579 }, Mov { destination: Relative(10), source: Relative(4) }, Jump { location: 579 }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U16, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Xor, bit_size: U1, lhs: Relative(7), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 583 }, Jump { location: 585 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U16, lhs: Relative(12), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U16, lhs: Relative(5), rhs: Relative(4) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(3), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 591 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65525 }, Const { destination: Relative(13), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U16, lhs: Relative(13), rhs: Relative(3) }, Const { destination: Relative(14), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U16, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(8), location: 598 }, Jump { location: 600 }, Mov { destination: Relative(9), source: Relative(15) }, Jump { location: 602 }, Mov { destination: Relative(9), source: Relative(3) }, Jump { location: 602 }, Const { destination: Relative(13), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U16, lhs: Relative(13), rhs: Relative(2) }, Const { destination: Relative(14), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U16, lhs: Relative(14), rhs: Relative(2) }, JumpIf { condition: Relative(10), location: 608 }, Jump { location: 610 }, Mov { destination: Relative(11), source: Relative(15) }, Jump { location: 612 }, Mov { destination: Relative(11), source: Relative(2) }, Jump { location: 612 }, BinaryIntOp { destination: Relative(6), op: Div, bit_size: U16, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(12), op: Xor, bit_size: U1, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(12), location: 616 }, Jump { location: 618 }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(6) }, BinaryIntOp { destination: Relative(7), op: Mul, bit_size: U16, lhs: Relative(6), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U16, lhs: Relative(3), rhs: Relative(7) }, Const { destination: Relative(6), bit_size: Integer(U16), value: 4 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U16, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 625 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U16, lhs: Relative(1), rhs: Relative(3) }, Mov { destination: Relative(1), source: Relative(5) }, Cast { destination: Relative(5), source: Relative(1), bit_size: Integer(U16) }, Cast { destination: Relative(7), source: Relative(3), bit_size: Integer(U16) }, Const { destination: Relative(8), bit_size: Integer(U16), value: 32768 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(7), rhs: Relative(8) }, Not { destination: Relative(7), source: Relative(9), bit_size: U1 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(5), rhs: Relative(8) }, BinaryIntOp { destination: Relative(5), op: Mul, bit_size: U1, lhs: Relative(9), rhs: Relative(7) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(5), rhs: Relative(7) }, JumpIf { condition: Relative(9), location: 637 }, Call { location: 844 }, Const { destination: Relative(15), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U16, lhs: Relative(15), rhs: Relative(1) }, Const { destination: Relative(16), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(17), op: Sub, bit_size: U16, lhs: Relative(16), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 643 }, Jump { location: 645 }, Mov { destination: Relative(11), source: Relative(17) }, Jump { location: 647 }, Mov { destination: Relative(11), source: Relative(1) }, Jump { location: 647 }, Const { destination: Relative(15), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U16, lhs: Relative(15), rhs: Relative(2) }, Const { destination: Relative(16), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(17), op: Sub, bit_size: U16, lhs: Relative(16), rhs: Relative(2) }, JumpIf { condition: Relative(12), location: 653 }, Jump { location: 655 }, Mov { destination: Relative(13), source: Relative(17) }, Jump { location: 657 }, Mov { destination: Relative(13), source: Relative(2) }, Jump { location: 657 }, BinaryIntOp { destination: Relative(7), op: Div, bit_size: U16, lhs: Relative(11), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: Xor, bit_size: U1, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 661 }, Jump { location: 663 }, Const { destination: Relative(15), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(7), op: Sub, bit_size: U16, lhs: Relative(15), rhs: Relative(7) }, BinaryIntOp { destination: Relative(9), op: Mul, bit_size: U16, lhs: Relative(7), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U16, lhs: Relative(1), rhs: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65532 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U16, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 670 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Const { destination: Relative(5), bit_size: Integer(U16), value: 2 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U16, lhs: Relative(4), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(7) }, Cast { destination: Relative(7), source: Relative(5), bit_size: Integer(U16) }, Cast { destination: Relative(9), source: Relative(4), bit_size: Integer(U16) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U16, lhs: Relative(9), rhs: Relative(8) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(7), rhs: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(4) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(7), rhs: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 682 }, Call { location: 872 }, Const { destination: Relative(14), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(14), rhs: Relative(3) }, Const { destination: Relative(15), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U16, lhs: Relative(15), rhs: Relative(3) }, JumpIf { condition: Relative(9), location: 688 }, Jump { location: 690 }, Mov { destination: Relative(10), source: Relative(16) }, Jump { location: 692 }, Mov { destination: Relative(10), source: Relative(3) }, Jump { location: 692 }, Const { destination: Relative(14), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U16, lhs: Relative(14), rhs: Relative(5) }, Const { destination: Relative(15), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U16, lhs: Relative(15), rhs: Relative(5) }, JumpIf { condition: Relative(11), location: 698 }, Jump { location: 700 }, Mov { destination: Relative(12), source: Relative(16) }, Jump { location: 702 }, Mov { destination: Relative(12), source: Relative(5) }, Jump { location: 702 }, BinaryIntOp { destination: Relative(7), op: Div, bit_size: U16, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: Xor, bit_size: U1, lhs: Relative(9), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 706 }, Jump { location: 708 }, Const { destination: Relative(14), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(7), op: Sub, bit_size: U16, lhs: Relative(14), rhs: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U16, lhs: Relative(7), rhs: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(3), rhs: Relative(8) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(6), rhs: Relative(4) }, JumpIf { condition: Relative(3), location: 714 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(1) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 720 }, Jump { location: 722 }, Mov { destination: Relative(8), source: Relative(14) }, Jump { location: 724 }, Mov { destination: Relative(8), source: Relative(1) }, Jump { location: 724 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(5) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(5) }, JumpIf { condition: Relative(9), location: 730 }, Jump { location: 732 }, Mov { destination: Relative(10), source: Relative(14) }, Jump { location: 734 }, Mov { destination: Relative(10), source: Relative(5) }, Jump { location: 734 }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U16, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Xor, bit_size: U1, lhs: Relative(7), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 738 }, Jump { location: 740 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(12), rhs: Relative(4) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U16, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U16, lhs: Relative(1), rhs: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(1), location: 746 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(5), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(7), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(9) }, Store { destination_pointer: Relative(2), source: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(1), source: Relative(5) }, Jump { location: 518 }, BinaryIntOp { destination: Relative(30), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, BinaryIntOp { destination: Relative(31), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(29) }, JumpIf { condition: Relative(31), location: 764 }, Call { location: 847 }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(32), rhs: Relative(30) }, Load { destination: Relative(31), source_pointer: Relative(33) }, Load { destination: Relative(30), source_pointer: Relative(27) }, Mov { destination: Direct(32771), source: Relative(30) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 850 }, Mov { destination: Relative(32), source: Direct(32773) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(1) }, Store { destination_pointer: Relative(34), source: Relative(31) }, Store { destination_pointer: Relative(27), source: Relative(32) }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(1), source: Relative(30) }, Jump { location: 432 }, Load { destination: Relative(9), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, Load { destination: Relative(11), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U8, lhs: Relative(10), rhs: Relative(11) }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U1, lhs: Relative(9), rhs: Relative(12) }, Store { destination_pointer: Relative(2), source: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(1), source: Relative(9) }, Jump { location: 262 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(6) }, JumpIf { condition: Relative(10), location: 795 }, Jump { location: 835 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryIntOp { destination: Relative(17), op: Mul, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(17), rhs: Relative(8) }, BinaryIntOp { destination: Relative(19), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(17) }, JumpIf { condition: Relative(19), location: 803 }, Call { location: 844 }, BinaryIntOp { destination: Relative(19), op: Shr, bit_size: U8, lhs: Relative(10), rhs: Relative(11) }, Const { destination: Relative(21), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(22), op: Div, bit_size: U8, lhs: Relative(19), rhs: Relative(21) }, BinaryIntOp { destination: Relative(23), op: Mul, bit_size: U8, lhs: Relative(22), rhs: Relative(21) }, BinaryIntOp { destination: Relative(20), op: Sub, bit_size: U8, lhs: Relative(19), rhs: Relative(23) }, Load { destination: Relative(19), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Direct(32835) }, JumpIf { condition: Relative(21), location: 812 }, Call { location: 847 }, Mov { destination: Direct(32771), source: Relative(19) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 17 }, Call { location: 850 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Store { destination_pointer: Relative(23), source: Relative(20) }, Const { destination: Relative(19), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(20), op: Div, bit_size: U8, lhs: Relative(10), rhs: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Mul, bit_size: U8, lhs: Relative(20), rhs: Relative(19) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U8, lhs: Relative(10), rhs: Relative(22) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Direct(32835) }, JumpIf { condition: Relative(10), location: 826 }, Call { location: 847 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 17 }, Call { location: 850 }, Mov { destination: Relative(10), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(17) }, Store { destination_pointer: Relative(20), source: Relative(18) }, Store { destination_pointer: Relative(9), source: Relative(10) }, Jump { location: 835 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, Mov { destination: Relative(13), source: Relative(10) }, Jump { location: 195 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 843 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 854 }, Jump { location: 856 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 871 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 868 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 861 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 871 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n if result {\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use super::{Eq, max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0_u64, 1), 0);\n assert_eq(min(0_u64, 0), 0);\n assert_eq(min(1_u64, 1), 1);\n assert_eq(min(255_u8, 0), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0_u64, 1), 1);\n assert_eq(max(0_u64, 0), 0);\n assert_eq(max(1_u64, 1), 1);\n assert_eq(max(255_u8, 0), 255);\n }\n\n #[test]\n fn correctly_handles_unequal_length_slices() {\n let slice_1 = &[0, 1, 2, 3];\n let slice_2 = &[0, 1, 2];\n assert(!slice_1.eq(slice_2));\n }\n}\n", "path": "std/cmp.nr" }, "50": { - "source": "global NIBBLE_LENGTH: u32 = 16;\n\nstruct U4 {\n inner: u8,\n}\n\nimpl U4 {\n fn zero() -> U4 {\n U4 { inner: 0 }\n }\n\n fn from_u8(x: u8) -> U4 {\n U4 { inner: x % 16 }\n }\n}\n\nimpl Eq for U4 {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nfn compact_decode(input: [u8; N], length: Field) -> ([U4; NIBBLE_LENGTH], Field) {\n assert(2 * input.len() <= NIBBLE_LENGTH);\n assert(length as u32 <= input.len());\n\n let mut nibble = [U4::zero(); NIBBLE_LENGTH];\n\n let first_nibble = U4::from_u8(input[0] >> 4);\n let parity = first_nibble.inner as u1;\n\n if parity == 1 {\n nibble[0] = U4::from_u8(input[0] & 0x0f);\n for i in 1..input.len() {\n if i as u32 < length as u32 {\n let x = input[i];\n nibble[2 * i - 1] = U4::from_u8(x >> 4);\n nibble[2 * i] = U4::from_u8(x & 0x0f);\n }\n }\n } else {\n for i in 0..2 {\n if (i as u32) < length as u32 - 1 {\n let x = input[i + 1];\n nibble[2 * i] = U4::from_u8(x >> 4);\n nibble[2 * i + 1] = U4::from_u8(x & 0x0f);\n }\n }\n }\n\n let out = (nibble, 2 * length + (parity as Field) - 2);\n\n out\n}\n\nfn enc(value: [u8; N], value_length: Field) -> ([u8; 32], Field) {\n assert(value.len() as u8 >= value_length as u8);\n let mut out_value = [0; 32];\n if value_length == 0 {\n let out = (out_value, value_length);\n out\n } else if value_length as u8 < 31 {\n out_value[0] = 0x80 + value_length as u8;\n\n for i in 1..value.len() {\n out_value[i] = value[i - 1];\n }\n\n let out = (out_value, value_length + 1);\n\n out\n } else {\n let out = (out_value, 32);\n out\n }\n}\n\nfn bitshift_literal_0() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 0;\n\n bits\n}\nfn bitshift_literal_4() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 4;\n\n bits\n}\nfn bitshift_variable(idx: u8) -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << idx;\n\n bits\n}\n\nfn main(x: [u8; 5], z: Field, u: i16, v: i16) {\n //Issue 1144\n let (nib, len) = compact_decode(x, z);\n assert(len == 5);\n assert(\n [nib[0], nib[1], nib[2], nib[3], nib[4]]\n == [U4::from_u8(15), U4::from_u8(1), U4::from_u8(12), U4::from_u8(11), U4::from_u8(8)],\n );\n // Issue 1169\n let val1 = [\n 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41, 0x12, 0x13,\n 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00,\n ];\n let val1_length = 20;\n\n let enc_val1 = enc(val1, val1_length);\n\n assert(\n enc_val1.0\n == [\n 0x94, 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41,\n 0x12, 0x13, 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00,\n ],\n );\n assert(enc_val1.1 == 21);\n // Issue 2399\n let result_0 = bitshift_literal_0();\n assert(result_0 == 1);\n let result_4 = bitshift_literal_4();\n assert(result_4 == 16);\n let result_0 = bitshift_variable(0);\n assert(result_0 == 1);\n let result_4 = bitshift_variable(4);\n assert(result_4 == 16);\n\n // Issue 6609\n assert(u % -13 == 0);\n assert(u % v == 0);\n assert(u % -11 == 4);\n assert(-u % -11 == -4);\n assert(u % -11 == u % (v + 2));\n assert(-u % -11 == -u % (v + 2));\n}\n", + "source": "global NIBBLE_LENGTH: u32 = 16;\n\nstruct U4 {\n inner: u8,\n}\n\nimpl U4 {\n fn zero() -> U4 {\n U4 { inner: 0 }\n }\n\n fn from_u8(x: u8) -> U4 {\n U4 { inner: x % 16 }\n }\n}\n\nimpl Eq for U4 {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nfn compact_decode(input: [u8; N], length: Field) -> ([U4; NIBBLE_LENGTH], Field) {\n assert(2 * input.len() <= NIBBLE_LENGTH);\n assert(length as u32 <= input.len());\n\n let mut nibble = [U4::zero(); NIBBLE_LENGTH];\n\n let first_nibble = U4::from_u8(input[0] >> 4);\n let parity = first_nibble.inner as u1;\n\n if parity == 1 {\n nibble[0] = U4::from_u8(input[0] & 0x0f);\n for i in 1..input.len() {\n if i as u32 < length as u32 {\n let x = input[i];\n nibble[2 * i - 1] = U4::from_u8(x >> 4);\n nibble[2 * i] = U4::from_u8(x & 0x0f);\n }\n }\n } else {\n for i in 0..2 {\n if (i as u32) < length as u32 - 1 {\n let x = input[i + 1];\n nibble[2 * i] = U4::from_u8(x >> 4);\n nibble[2 * i + 1] = U4::from_u8(x & 0x0f);\n }\n }\n }\n\n let out = (nibble, 2 * length + (parity as Field) - 2);\n\n out\n}\n\nfn enc(value: [u8; N], value_length: Field) -> ([u8; 32], Field) {\n assert(value.len() as u8 >= value_length as u8);\n let mut out_value = [0; 32];\n if value_length == 0 {\n let out = (out_value, value_length);\n out\n } else if value_length as u8 < 31 {\n out_value[0] = 0x80 + value_length as u8;\n\n for i in 1..value.len() {\n out_value[i] = value[i - 1];\n }\n\n let out = (out_value, value_length + 1);\n\n out\n } else {\n let out = (out_value, 32);\n out\n }\n}\n\nfn bitshift_literal_0() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 0;\n\n bits\n}\nfn bitshift_literal_4() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 4;\n\n bits\n}\nfn bitshift_variable(idx: u64) -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << idx;\n\n bits\n}\n\nfn main(x: [u8; 5], z: Field, u: i16, v: i16) {\n //Issue 1144\n let (nib, len) = compact_decode(x, z);\n assert(len == 5);\n assert(\n [nib[0], nib[1], nib[2], nib[3], nib[4]]\n == [U4::from_u8(15), U4::from_u8(1), U4::from_u8(12), U4::from_u8(11), U4::from_u8(8)],\n );\n // Issue 1169\n let val1 = [\n 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41, 0x12, 0x13,\n 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00,\n ];\n let val1_length = 20;\n\n let enc_val1 = enc(val1, val1_length);\n\n assert(\n enc_val1.0\n == [\n 0x94, 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41,\n 0x12, 0x13, 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00,\n ],\n );\n assert(enc_val1.1 == 21);\n // Issue 2399\n let result_0 = bitshift_literal_0();\n assert(result_0 == 1);\n let result_4 = bitshift_literal_4();\n assert(result_4 == 16);\n let result_0 = bitshift_variable(0);\n assert(result_0 == 1);\n let result_4 = bitshift_variable(4);\n assert(result_4 == 16);\n\n // Issue 6609\n assert(u % -13 == 0);\n assert(u % v == 0);\n assert(u % -11 == 4);\n assert(-u % -11 == -4);\n assert(u % -11 == u % (v + 2));\n assert(-u % -11 == -u % (v + 2));\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index cd141b65bc3..482f3ab425e 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_1144_1169_2399_6609/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -80,14 +80,14 @@ expression: artifact "unconstrained func 0", "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32844 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 8 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U8) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U8) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U8) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U16) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U16) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32836 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 33 }, Mov { destination: Relative(1), source: Relative(5) }, Mov { destination: Relative(2), source: Direct(32841) }, Mov { destination: Relative(3), source: Direct(32842) }, Mov { destination: Relative(4), source: Direct(32843) }, Call { location: 44 }, Call { location: 46 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 43 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 36 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 16 }, Return, Call { location: 838 }, Cast { destination: Relative(6), source: Relative(2), bit_size: Integer(U32) }, Cast { destination: Relative(5), source: Relative(6), bit_size: Field }, Cast { destination: Relative(6), source: Relative(5), bit_size: Integer(U32) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Const { destination: Relative(8), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 57 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Const { destination: Relative(7), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 16 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Mov { destination: Relative(11), source: Relative(9) }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 72 }, Store { destination_pointer: Relative(11), source: Relative(7) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Jump { location: 66 }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Load { destination: Relative(10), source_pointer: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U8), value: 4 }, BinaryIntOp { destination: Relative(12), op: Shr, bit_size: U8, lhs: Relative(10), rhs: Relative(11) }, Const { destination: Relative(14), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(15), op: Div, bit_size: U8, lhs: Relative(12), rhs: Relative(14) }, BinaryIntOp { destination: Relative(16), op: Mul, bit_size: U8, lhs: Relative(15), rhs: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Sub, bit_size: U8, lhs: Relative(12), rhs: Relative(16) }, Cast { destination: Relative(14), source: Relative(13), bit_size: Integer(U1) }, Cast { destination: Relative(12), source: Relative(14), bit_size: Integer(U8) }, Cast { destination: Relative(13), source: Relative(12), bit_size: Integer(U1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(16), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 151 }, Jump { location: 92 }, BinaryIntOp { destination: Relative(13), op: Sub, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(6) }, JumpIf { condition: Relative(17), location: 96 }, Call { location: 844 }, Mov { destination: Relative(10), source: Relative(14) }, Jump { location: 98 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(6), location: 102 }, Jump { location: 101 }, Jump { location: 199 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(13) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(8) }, JumpIf { condition: Relative(6), location: 106 }, Jump { location: 149 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 109 }, Call { location: 847 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(17) }, Load { destination: Relative(6), source_pointer: Relative(19) }, BinaryIntOp { destination: Relative(18), op: Mul, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, BinaryIntOp { destination: Relative(19), op: Shr, bit_size: U8, lhs: Relative(6), rhs: Relative(11) }, Const { destination: Relative(21), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(22), op: Div, bit_size: U8, lhs: Relative(19), rhs: Relative(21) }, BinaryIntOp { destination: Relative(23), op: Mul, bit_size: U8, lhs: Relative(22), rhs: Relative(21) }, BinaryIntOp { destination: Relative(20), op: Sub, bit_size: U8, lhs: Relative(19), rhs: Relative(23) }, Load { destination: Relative(19), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Direct(32835) }, JumpIf { condition: Relative(21), location: 122 }, Call { location: 847 }, Mov { destination: Direct(32771), source: Relative(19) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 17 }, Call { location: 850 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Store { destination_pointer: Relative(23), source: Relative(20) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(8) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(18), rhs: Relative(19) }, JumpIf { condition: Relative(20), location: 133 }, Call { location: 872 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(22), op: Div, bit_size: U8, lhs: Relative(6), rhs: Relative(20) }, BinaryIntOp { destination: Relative(23), op: Mul, bit_size: U8, lhs: Relative(22), rhs: Relative(20) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U8, lhs: Relative(6), rhs: Relative(23) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(19), rhs: Direct(32835) }, JumpIf { condition: Relative(6), location: 140 }, Call { location: 847 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 17 }, Call { location: 850 }, Mov { destination: Relative(6), source: Direct(32773) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(18) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Jump { location: 149 }, Mov { destination: Relative(10), source: Relative(17) }, Jump { location: 98 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(19), op: Div, bit_size: U8, lhs: Relative(10), rhs: Relative(18) }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U8, lhs: Relative(19), rhs: Relative(18) }, BinaryIntOp { destination: Relative(17), op: Sub, bit_size: U8, lhs: Relative(10), rhs: Relative(20) }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 17 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(18) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Relative(19), source: Relative(18) }, Store { destination_pointer: Relative(19), source: Relative(17) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(7) }, Store { destination_pointer: Relative(9), source: Relative(10) }, Mov { destination: Relative(13), source: Relative(8) }, Jump { location: 195 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(5) }, JumpIf { condition: Relative(10), location: 792 }, Jump { location: 198 }, Jump { location: 199 }, Load { destination: Relative(6), source_pointer: Relative(9) }, Const { destination: Relative(9), bit_size: Field, value: 2 }, BinaryFieldOp { destination: Relative(10), op: Mul, lhs: Relative(9), rhs: Relative(2) }, Cast { destination: Relative(2), source: Relative(12), bit_size: Field }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(10), rhs: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Sub, lhs: Relative(11), rhs: Relative(9) }, Const { destination: Relative(9), bit_size: Field, value: 5 }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(2), rhs: Relative(9) }, JumpIf { condition: Relative(10), location: 210 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(15) }, Load { destination: Relative(9), source_pointer: Relative(10) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(12) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(10) }, Load { destination: Relative(12), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(13) }, Mov { destination: Relative(6), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(13) }, Store { destination_pointer: Relative(15), source: Relative(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(9) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(11) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(12) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(10) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 15 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 12 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 11 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 8 }, Mov { destination: Relative(13), source: Direct(1) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(15) }, IndirectConst { destination_pointer: Relative(13), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Mov { destination: Relative(17), source: Relative(15) }, Store { destination_pointer: Relative(17), source: Relative(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(9) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(10) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(11) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(12) }, Mov { destination: Relative(2), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(16) }, Mov { destination: Relative(1), source: Relative(14) }, Jump { location: 262 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(9), location: 779 }, Jump { location: 265 }, Load { destination: Relative(5), source_pointer: Relative(2) }, JumpIf { condition: Relative(5), location: 269 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Const { destination: Relative(2), bit_size: Integer(U8), value: 184 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 143 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 97 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 230 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 251 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 218 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 131 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 255 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 250 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 190 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 54 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 65 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 18 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 19 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 128 }, Const { destination: Relative(24), bit_size: Integer(U8), value: 57 }, Const { destination: Relative(25), bit_size: Integer(U8), value: 24 }, Mov { destination: Relative(26), source: Direct(1) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(27) }, IndirectConst { destination_pointer: Relative(26), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Mov { destination: Relative(28), source: Relative(27) }, Store { destination_pointer: Relative(28), source: Relative(2) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(5) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(6) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(9) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(10) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(12) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(10) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(13) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(15) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(17) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(18) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(19) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(20) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(21) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(22) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(23) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(24) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(23) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(25) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(7) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(28), bit_size: Integer(U8), value: 148 }, Mov { destination: Relative(29), source: Direct(1) }, Const { destination: Relative(30), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(30) }, IndirectConst { destination_pointer: Relative(29), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Mov { destination: Relative(31), source: Relative(30) }, Store { destination_pointer: Relative(31), source: Relative(28) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(7) }, Store { destination_pointer: Relative(27), source: Relative(29) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 432 }, BinaryIntOp { destination: Relative(30), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(29) }, JumpIf { condition: Relative(30), location: 760 }, Jump { location: 435 }, Load { destination: Relative(26), source_pointer: Relative(27) }, Load { destination: Relative(27), source_pointer: Relative(26) }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(31), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(27) }, Not { destination: Relative(31), source: Relative(31), bit_size: U1 }, JumpIf { condition: Relative(31), location: 442 }, Call { location: 875 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Mov { destination: Relative(27), source: Direct(1) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(31) }, IndirectConst { destination_pointer: Relative(27), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Mov { destination: Relative(32), source: Relative(31) }, Store { destination_pointer: Relative(32), source: Relative(28) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(2) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(5) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(6) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(9) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(10) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(11) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(12) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(10) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(13) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(15) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(17) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(18) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(19) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(21) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(22) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(23) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(24) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(23) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(25) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, Store { destination_pointer: Relative(32), source: Relative(7) }, Mov { destination: Relative(2), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(16) }, Mov { destination: Relative(1), source: Relative(14) }, Jump { location: 518 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(29) }, JumpIf { condition: Relative(5), location: 747 }, Jump { location: 521 }, Load { destination: Relative(1), source_pointer: Relative(2) }, JumpIf { condition: Relative(1), location: 525 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Const { destination: Relative(1), bit_size: Integer(U16), value: 65523 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(3) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 532 }, Jump { location: 534 }, Mov { destination: Relative(8), source: Relative(14) }, Jump { location: 536 }, Mov { destination: Relative(8), source: Relative(3) }, Jump { location: 536 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(1) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(1) }, JumpIf { condition: Relative(9), location: 542 }, Jump { location: 544 }, Mov { destination: Relative(10), source: Relative(14) }, Jump { location: 546 }, Mov { destination: Relative(10), source: Relative(1) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U16, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Xor, bit_size: U1, lhs: Relative(7), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 550 }, Jump { location: 552 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U16, lhs: Relative(12), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U16, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(3), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 559 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(3) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 565 }, Jump { location: 567 }, Mov { destination: Relative(8), source: Relative(14) }, Jump { location: 569 }, Mov { destination: Relative(8), source: Relative(3) }, Jump { location: 569 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(4) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(4) }, JumpIf { condition: Relative(9), location: 575 }, Jump { location: 577 }, Mov { destination: Relative(10), source: Relative(14) }, Jump { location: 579 }, Mov { destination: Relative(10), source: Relative(4) }, Jump { location: 579 }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U16, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Xor, bit_size: U1, lhs: Relative(7), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 583 }, Jump { location: 585 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U16, lhs: Relative(12), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U16, lhs: Relative(5), rhs: Relative(4) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U16, lhs: Relative(3), rhs: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 591 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65525 }, Const { destination: Relative(13), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U16, lhs: Relative(13), rhs: Relative(3) }, Const { destination: Relative(14), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U16, lhs: Relative(14), rhs: Relative(3) }, JumpIf { condition: Relative(8), location: 598 }, Jump { location: 600 }, Mov { destination: Relative(9), source: Relative(15) }, Jump { location: 602 }, Mov { destination: Relative(9), source: Relative(3) }, Jump { location: 602 }, Const { destination: Relative(13), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U16, lhs: Relative(13), rhs: Relative(2) }, Const { destination: Relative(14), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U16, lhs: Relative(14), rhs: Relative(2) }, JumpIf { condition: Relative(10), location: 608 }, Jump { location: 610 }, Mov { destination: Relative(11), source: Relative(15) }, Jump { location: 612 }, Mov { destination: Relative(11), source: Relative(2) }, Jump { location: 612 }, BinaryIntOp { destination: Relative(6), op: Div, bit_size: U16, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(12), op: Xor, bit_size: U1, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(12), location: 616 }, Jump { location: 618 }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(6) }, BinaryIntOp { destination: Relative(7), op: Mul, bit_size: U16, lhs: Relative(6), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U16, lhs: Relative(3), rhs: Relative(7) }, Const { destination: Relative(6), bit_size: Integer(U16), value: 4 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U16, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 625 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U16, lhs: Relative(1), rhs: Relative(3) }, Mov { destination: Relative(1), source: Relative(5) }, Cast { destination: Relative(5), source: Relative(1), bit_size: Integer(U16) }, Cast { destination: Relative(7), source: Relative(3), bit_size: Integer(U16) }, Const { destination: Relative(8), bit_size: Integer(U16), value: 32768 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(7), rhs: Relative(8) }, Not { destination: Relative(7), source: Relative(9), bit_size: U1 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(5), rhs: Relative(8) }, BinaryIntOp { destination: Relative(5), op: Mul, bit_size: U1, lhs: Relative(9), rhs: Relative(7) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(5), rhs: Relative(7) }, JumpIf { condition: Relative(9), location: 637 }, Call { location: 844 }, Const { destination: Relative(15), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U16, lhs: Relative(15), rhs: Relative(1) }, Const { destination: Relative(16), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(17), op: Sub, bit_size: U16, lhs: Relative(16), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 643 }, Jump { location: 645 }, Mov { destination: Relative(11), source: Relative(17) }, Jump { location: 647 }, Mov { destination: Relative(11), source: Relative(1) }, Jump { location: 647 }, Const { destination: Relative(15), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U16, lhs: Relative(15), rhs: Relative(2) }, Const { destination: Relative(16), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(17), op: Sub, bit_size: U16, lhs: Relative(16), rhs: Relative(2) }, JumpIf { condition: Relative(12), location: 653 }, Jump { location: 655 }, Mov { destination: Relative(13), source: Relative(17) }, Jump { location: 657 }, Mov { destination: Relative(13), source: Relative(2) }, Jump { location: 657 }, BinaryIntOp { destination: Relative(7), op: Div, bit_size: U16, lhs: Relative(11), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: Xor, bit_size: U1, lhs: Relative(10), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 661 }, Jump { location: 663 }, Const { destination: Relative(15), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(7), op: Sub, bit_size: U16, lhs: Relative(15), rhs: Relative(7) }, BinaryIntOp { destination: Relative(9), op: Mul, bit_size: U16, lhs: Relative(7), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U16, lhs: Relative(1), rhs: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U16), value: 65532 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U16, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 670 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Const { destination: Relative(5), bit_size: Integer(U16), value: 2 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U16, lhs: Relative(4), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(7) }, Cast { destination: Relative(7), source: Relative(5), bit_size: Integer(U16) }, Cast { destination: Relative(9), source: Relative(4), bit_size: Integer(U16) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U16, lhs: Relative(9), rhs: Relative(8) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(7), rhs: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(4) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(7), rhs: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 682 }, Call { location: 872 }, Const { destination: Relative(14), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(14), rhs: Relative(3) }, Const { destination: Relative(15), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U16, lhs: Relative(15), rhs: Relative(3) }, JumpIf { condition: Relative(9), location: 688 }, Jump { location: 690 }, Mov { destination: Relative(10), source: Relative(16) }, Jump { location: 692 }, Mov { destination: Relative(10), source: Relative(3) }, Jump { location: 692 }, Const { destination: Relative(14), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U16, lhs: Relative(14), rhs: Relative(5) }, Const { destination: Relative(15), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U16, lhs: Relative(15), rhs: Relative(5) }, JumpIf { condition: Relative(11), location: 698 }, Jump { location: 700 }, Mov { destination: Relative(12), source: Relative(16) }, Jump { location: 702 }, Mov { destination: Relative(12), source: Relative(5) }, Jump { location: 702 }, BinaryIntOp { destination: Relative(7), op: Div, bit_size: U16, lhs: Relative(10), rhs: Relative(12) }, BinaryIntOp { destination: Relative(13), op: Xor, bit_size: U1, lhs: Relative(9), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 706 }, Jump { location: 708 }, Const { destination: Relative(14), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(7), op: Sub, bit_size: U16, lhs: Relative(14), rhs: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U16, lhs: Relative(7), rhs: Relative(5) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(3), rhs: Relative(8) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(6), rhs: Relative(4) }, JumpIf { condition: Relative(3), location: 714 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(1) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 720 }, Jump { location: 722 }, Mov { destination: Relative(8), source: Relative(14) }, Jump { location: 724 }, Mov { destination: Relative(8), source: Relative(1) }, Jump { location: 724 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 32767 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U16, lhs: Relative(12), rhs: Relative(5) }, Const { destination: Relative(13), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(14), op: Sub, bit_size: U16, lhs: Relative(13), rhs: Relative(5) }, JumpIf { condition: Relative(9), location: 730 }, Jump { location: 732 }, Mov { destination: Relative(10), source: Relative(14) }, Jump { location: 734 }, Mov { destination: Relative(10), source: Relative(5) }, Jump { location: 734 }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U16, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(11), op: Xor, bit_size: U1, lhs: Relative(7), rhs: Relative(9) }, JumpIf { condition: Relative(11), location: 738 }, Jump { location: 740 }, Const { destination: Relative(12), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U16, lhs: Relative(12), rhs: Relative(4) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U16, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U16, lhs: Relative(1), rhs: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(1), location: 746 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(5), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(7), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(9) }, Store { destination_pointer: Relative(2), source: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(1), source: Relative(5) }, Jump { location: 518 }, BinaryIntOp { destination: Relative(30), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, BinaryIntOp { destination: Relative(31), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(29) }, JumpIf { condition: Relative(31), location: 764 }, Call { location: 847 }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(32), rhs: Relative(30) }, Load { destination: Relative(31), source_pointer: Relative(33) }, Load { destination: Relative(30), source_pointer: Relative(27) }, Mov { destination: Direct(32771), source: Relative(30) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 850 }, Mov { destination: Relative(32), source: Direct(32773) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(32), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(1) }, Store { destination_pointer: Relative(34), source: Relative(31) }, Store { destination_pointer: Relative(27), source: Relative(32) }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(1), source: Relative(30) }, Jump { location: 432 }, Load { destination: Relative(9), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, Load { destination: Relative(11), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U8, lhs: Relative(10), rhs: Relative(11) }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U1, lhs: Relative(9), rhs: Relative(12) }, Store { destination_pointer: Relative(2), source: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(1), source: Relative(9) }, Jump { location: 262 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(6) }, JumpIf { condition: Relative(10), location: 795 }, Jump { location: 835 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryIntOp { destination: Relative(17), op: Mul, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(17), rhs: Relative(8) }, BinaryIntOp { destination: Relative(19), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(17) }, JumpIf { condition: Relative(19), location: 803 }, Call { location: 844 }, BinaryIntOp { destination: Relative(19), op: Shr, bit_size: U8, lhs: Relative(10), rhs: Relative(11) }, Const { destination: Relative(21), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(22), op: Div, bit_size: U8, lhs: Relative(19), rhs: Relative(21) }, BinaryIntOp { destination: Relative(23), op: Mul, bit_size: U8, lhs: Relative(22), rhs: Relative(21) }, BinaryIntOp { destination: Relative(20), op: Sub, bit_size: U8, lhs: Relative(19), rhs: Relative(23) }, Load { destination: Relative(19), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(21), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Direct(32835) }, JumpIf { condition: Relative(21), location: 812 }, Call { location: 847 }, Mov { destination: Direct(32771), source: Relative(19) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 17 }, Call { location: 850 }, Mov { destination: Relative(21), source: Direct(32773) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Store { destination_pointer: Relative(23), source: Relative(20) }, Const { destination: Relative(19), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(20), op: Div, bit_size: U8, lhs: Relative(10), rhs: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Mul, bit_size: U8, lhs: Relative(20), rhs: Relative(19) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U8, lhs: Relative(10), rhs: Relative(22) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Direct(32835) }, JumpIf { condition: Relative(10), location: 826 }, Call { location: 847 }, Mov { destination: Direct(32771), source: Relative(21) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 17 }, Call { location: 850 }, Mov { destination: Relative(10), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(17) }, Store { destination_pointer: Relative(20), source: Relative(18) }, Store { destination_pointer: Relative(9), source: Relative(10) }, Jump { location: 835 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, Mov { destination: Relative(13), source: Relative(10) }, Jump { location: 195 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 843 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 854 }, Jump { location: 856 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 871 }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32773) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 868 }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, Store { destination_pointer: Direct(32779), source: Direct(32776) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Jump { location: 861 }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32774), op: Sub, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Jump { location: 871 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n if result {\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use super::{Eq, max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0_u64, 1), 0);\n assert_eq(min(0_u64, 0), 0);\n assert_eq(min(1_u64, 1), 1);\n assert_eq(min(255_u8, 0), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0_u64, 1), 1);\n assert_eq(max(0_u64, 0), 0);\n assert_eq(max(1_u64, 1), 1);\n assert_eq(max(255_u8, 0), 255);\n }\n\n #[test]\n fn correctly_handles_unequal_length_slices() {\n let slice_1 = &[0, 1, 2, 3];\n let slice_2 = &[0, 1, 2];\n assert(!slice_1.eq(slice_2));\n }\n}\n", "path": "std/cmp.nr" }, "50": { - "source": "global NIBBLE_LENGTH: u32 = 16;\n\nstruct U4 {\n inner: u8,\n}\n\nimpl U4 {\n fn zero() -> U4 {\n U4 { inner: 0 }\n }\n\n fn from_u8(x: u8) -> U4 {\n U4 { inner: x % 16 }\n }\n}\n\nimpl Eq for U4 {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nfn compact_decode(input: [u8; N], length: Field) -> ([U4; NIBBLE_LENGTH], Field) {\n assert(2 * input.len() <= NIBBLE_LENGTH);\n assert(length as u32 <= input.len());\n\n let mut nibble = [U4::zero(); NIBBLE_LENGTH];\n\n let first_nibble = U4::from_u8(input[0] >> 4);\n let parity = first_nibble.inner as u1;\n\n if parity == 1 {\n nibble[0] = U4::from_u8(input[0] & 0x0f);\n for i in 1..input.len() {\n if i as u32 < length as u32 {\n let x = input[i];\n nibble[2 * i - 1] = U4::from_u8(x >> 4);\n nibble[2 * i] = U4::from_u8(x & 0x0f);\n }\n }\n } else {\n for i in 0..2 {\n if (i as u32) < length as u32 - 1 {\n let x = input[i + 1];\n nibble[2 * i] = U4::from_u8(x >> 4);\n nibble[2 * i + 1] = U4::from_u8(x & 0x0f);\n }\n }\n }\n\n let out = (nibble, 2 * length + (parity as Field) - 2);\n\n out\n}\n\nfn enc(value: [u8; N], value_length: Field) -> ([u8; 32], Field) {\n assert(value.len() as u8 >= value_length as u8);\n let mut out_value = [0; 32];\n if value_length == 0 {\n let out = (out_value, value_length);\n out\n } else if value_length as u8 < 31 {\n out_value[0] = 0x80 + value_length as u8;\n\n for i in 1..value.len() {\n out_value[i] = value[i - 1];\n }\n\n let out = (out_value, value_length + 1);\n\n out\n } else {\n let out = (out_value, 32);\n out\n }\n}\n\nfn bitshift_literal_0() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 0;\n\n bits\n}\nfn bitshift_literal_4() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 4;\n\n bits\n}\nfn bitshift_variable(idx: u8) -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << idx;\n\n bits\n}\n\nfn main(x: [u8; 5], z: Field, u: i16, v: i16) {\n //Issue 1144\n let (nib, len) = compact_decode(x, z);\n assert(len == 5);\n assert(\n [nib[0], nib[1], nib[2], nib[3], nib[4]]\n == [U4::from_u8(15), U4::from_u8(1), U4::from_u8(12), U4::from_u8(11), U4::from_u8(8)],\n );\n // Issue 1169\n let val1 = [\n 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41, 0x12, 0x13,\n 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00,\n ];\n let val1_length = 20;\n\n let enc_val1 = enc(val1, val1_length);\n\n assert(\n enc_val1.0\n == [\n 0x94, 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41,\n 0x12, 0x13, 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00,\n ],\n );\n assert(enc_val1.1 == 21);\n // Issue 2399\n let result_0 = bitshift_literal_0();\n assert(result_0 == 1);\n let result_4 = bitshift_literal_4();\n assert(result_4 == 16);\n let result_0 = bitshift_variable(0);\n assert(result_0 == 1);\n let result_4 = bitshift_variable(4);\n assert(result_4 == 16);\n\n // Issue 6609\n assert(u % -13 == 0);\n assert(u % v == 0);\n assert(u % -11 == 4);\n assert(-u % -11 == -4);\n assert(u % -11 == u % (v + 2));\n assert(-u % -11 == -u % (v + 2));\n}\n", + "source": "global NIBBLE_LENGTH: u32 = 16;\n\nstruct U4 {\n inner: u8,\n}\n\nimpl U4 {\n fn zero() -> U4 {\n U4 { inner: 0 }\n }\n\n fn from_u8(x: u8) -> U4 {\n U4 { inner: x % 16 }\n }\n}\n\nimpl Eq for U4 {\n fn eq(self, other: Self) -> bool {\n self.inner == other.inner\n }\n}\n\nfn compact_decode(input: [u8; N], length: Field) -> ([U4; NIBBLE_LENGTH], Field) {\n assert(2 * input.len() <= NIBBLE_LENGTH);\n assert(length as u32 <= input.len());\n\n let mut nibble = [U4::zero(); NIBBLE_LENGTH];\n\n let first_nibble = U4::from_u8(input[0] >> 4);\n let parity = first_nibble.inner as u1;\n\n if parity == 1 {\n nibble[0] = U4::from_u8(input[0] & 0x0f);\n for i in 1..input.len() {\n if i as u32 < length as u32 {\n let x = input[i];\n nibble[2 * i - 1] = U4::from_u8(x >> 4);\n nibble[2 * i] = U4::from_u8(x & 0x0f);\n }\n }\n } else {\n for i in 0..2 {\n if (i as u32) < length as u32 - 1 {\n let x = input[i + 1];\n nibble[2 * i] = U4::from_u8(x >> 4);\n nibble[2 * i + 1] = U4::from_u8(x & 0x0f);\n }\n }\n }\n\n let out = (nibble, 2 * length + (parity as Field) - 2);\n\n out\n}\n\nfn enc(value: [u8; N], value_length: Field) -> ([u8; 32], Field) {\n assert(value.len() as u8 >= value_length as u8);\n let mut out_value = [0; 32];\n if value_length == 0 {\n let out = (out_value, value_length);\n out\n } else if value_length as u8 < 31 {\n out_value[0] = 0x80 + value_length as u8;\n\n for i in 1..value.len() {\n out_value[i] = value[i - 1];\n }\n\n let out = (out_value, value_length + 1);\n\n out\n } else {\n let out = (out_value, 32);\n out\n }\n}\n\nfn bitshift_literal_0() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 0;\n\n bits\n}\nfn bitshift_literal_4() -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << 4;\n\n bits\n}\nfn bitshift_variable(idx: u64) -> u64 {\n let mut bits: u64 = 0;\n bits |= 1 << idx;\n\n bits\n}\n\nfn main(x: [u8; 5], z: Field, u: i16, v: i16) {\n //Issue 1144\n let (nib, len) = compact_decode(x, z);\n assert(len == 5);\n assert(\n [nib[0], nib[1], nib[2], nib[3], nib[4]]\n == [U4::from_u8(15), U4::from_u8(1), U4::from_u8(12), U4::from_u8(11), U4::from_u8(8)],\n );\n // Issue 1169\n let val1 = [\n 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41, 0x12, 0x13,\n 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00,\n ];\n let val1_length = 20;\n\n let enc_val1 = enc(val1, val1_length);\n\n assert(\n enc_val1.0\n == [\n 0x94, 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41,\n 0x12, 0x13, 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00,\n ],\n );\n assert(enc_val1.1 == 21);\n // Issue 2399\n let result_0 = bitshift_literal_0();\n assert(result_0 == 1);\n let result_4 = bitshift_literal_4();\n assert(result_4 == 16);\n let result_0 = bitshift_variable(0);\n assert(result_0 == 1);\n let result_4 = bitshift_variable(4);\n assert(result_4 == 16);\n\n // Issue 6609\n assert(u % -13 == 0);\n assert(u % v == 0);\n assert(u % -11 == 4);\n assert(-u % -11 == -4);\n assert(u % -11 == u % (v + 2));\n assert(-u % -11 == -u % (v + 2));\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__expanded.snap index 29557136b43..d797e6bd520 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__expanded.snap @@ -3,6 +3,6 @@ source: tooling/nargo_cli/tests/execute.rs expression: expanded_code --- fn main(x: u8) { - let value: u32 = 1_u32 >> x; + let value: u32 = 1_u32 >> 7_u32; assert(value == 0_u32); } diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index d22673ddca1..61d871723db 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -18,84 +18,20 @@ expression: artifact } ], "return_type": null, - "error_types": { - "5795655218219125583": { - "error_kind": "string", - "string": "Field failed to decompose into specified 8 limbs" - } - } + "error_types": {} }, "bytecode": [ "func 0", - "current witness index : _35", + "current witness index : _0", "private parameters indices : [_0]", "public parameters indices : []", "return value indices : []", - "BLACKBOX::RANGE [(_0, 8)] []", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 224 ], EXPR [ 256 ]], outputs: [_1, _2]", - "BLACKBOX::RANGE [(_1, 1)] []", - "BLACKBOX::RANGE [(_2, 8)] []", - "EXPR [ (1, _0) (-256, _1) (-1, _2) 224 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _1, _0) (1, _0) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_3, _4, _5, _6, _7, _8, _9, _10]]", - "BLACKBOX::RANGE [(_3, 1)] []", - "BLACKBOX::RANGE [(_4, 1)] []", - "BLACKBOX::RANGE [(_5, 1)] []", - "BLACKBOX::RANGE [(_6, 1)] []", - "BLACKBOX::RANGE [(_7, 1)] []", - "BLACKBOX::RANGE [(_8, 1)] []", - "BLACKBOX::RANGE [(_9, 1)] []", - "BLACKBOX::RANGE [(_10, 1)] []", - "EXPR [ (-1, _0, _1) (1, _0) (-1, _3) (-2, _4) (-4, _5) (-8, _6) (-16, _7) (-32, _8) (-64, _9) (-128, _10) 0 ]", - "EXPR [ (1, _10, _10) (2, _10) (-1, _11) 1 ]", - "EXPR [ (-1, _9) (-1, _12) 1 ]", - "EXPR [ (2, _9, _11) (1, _11, _12) (-1, _13) 0 ]", - "EXPR [ (1, _13, _13) (-1, _14) 0 ]", - "EXPR [ (-1, _8) (-1, _15) 1 ]", - "EXPR [ (2, _8, _14) (1, _14, _15) (-1, _16) 0 ]", - "EXPR [ (1, _16, _16) (-1, _17) 0 ]", - "EXPR [ (-1, _7) (-1, _18) 1 ]", - "EXPR [ (2, _7, _17) (1, _17, _18) (-1, _19) 0 ]", - "EXPR [ (1, _19, _19) (-1, _20) 0 ]", - "EXPR [ (-1, _6) (-1, _21) 1 ]", - "EXPR [ (2, _6, _20) (1, _20, _21) (-1, _22) 0 ]", - "EXPR [ (1, _22, _22) (-1, _23) 0 ]", - "EXPR [ (-1, _5) (-1, _24) 1 ]", - "EXPR [ (2, _5, _23) (1, _23, _24) (-1, _25) 0 ]", - "EXPR [ (1, _25, _25) (-1, _26) 0 ]", - "EXPR [ (-1, _4) (-1, _27) 1 ]", - "EXPR [ (2, _4, _26) (1, _26, _27) (-1, _28) 0 ]", - "EXPR [ (1, _28, _28) (-1, _29) 0 ]", - "EXPR [ (-1, _3) (-1, _30) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _29, _3) (1, _29, _30) 0 ]], outputs: [_31]", - "EXPR [ (2, _3, _29) (1, _29, _30) (-1, _32) 0 ]", - "EXPR [ (1, _31, _32) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ 1 ], EXPR [ (1, _32) 0 ]], outputs: [_33, _34]", - "BLACKBOX::RANGE [(_33, 32)] []", - "BLACKBOX::RANGE [(_34, 32)] []", - "EXPR [ (1, _32) (-1, _34) (-1, _35) -1 ]", - "BLACKBOX::RANGE [(_35, 32)] []", - "EXPR [ (-1, _32, _33) (-1, _34) 1 ]", - "EXPR [ (-1, _1, _33) (1, _33) 0 ]", - "unconstrained func 0", - "[Const { destination: Direct(10), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(11), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(10), offset_address: Direct(11) }, BinaryFieldOp { destination: Direct(2), op: IntegerDiv, lhs: Direct(0), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Mul, lhs: Direct(2), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Sub, lhs: Direct(0), rhs: Direct(1) }, Mov { destination: Direct(0), source: Direct(2) }, Stop { return_data: HeapVector { pointer: Direct(11), size: Direct(10) } }]", - "unconstrained func 1", - "[Const { destination: Direct(5), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(6), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(7), bit_size: Integer(U32), value: 3 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(7), offset_address: Direct(5) }, Cast { destination: Direct(1), source: Direct(1), bit_size: Integer(U32) }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(7), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(3), op: IntegerDiv, lhs: Direct(0), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Mul, lhs: Direct(3), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Sub, lhs: Direct(0), rhs: Direct(4) }, Store { destination_pointer: Direct(9), source: Direct(4) }, BinaryIntOp { destination: Direct(9), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(6) }, Mov { destination: Direct(0), source: Direct(3) }, BinaryIntOp { destination: Direct(8), op: LessThan, bit_size: U32, lhs: Direct(9), rhs: Direct(7) }, JumpIf { condition: Direct(8), location: 7 }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, Stop { return_data: HeapVector { pointer: Direct(9), size: Direct(1) } }]", - "unconstrained func 2", - "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" + "BLACKBOX::RANGE [(_0, 8)] []" ], - "debug_symbols": "jdJBboMwEAXQu3jNgpkhTZurVBUyYCJLlkEOVKoQd6+ZD22yiJTNGDz+T9h4MZ1r5mvtYz/czOVzMU3yIfhrHYbWTn6IeXZZC3O81lNyLk+Zu35OjTa5OJlLnEMozLcNsy66jTbqONmUu2VhXOzymMHeB7c9rcV/unwepZL2MJXnv/jp9TzLkRd6yH/lN9v69LBjQ3lhYViraK20nrS+aT1rfdf6oZVKDEgT4oQ8ASAIBIJgEBCCwlB4/wYoDIWhMBSGwlAYCkMRKAJF9q1AESgCRaAIFIEiUCooFZQKSrWfSFZ43c48edsEt1+Vfo7t3c2Zfsajc9ytMQ2t6+bktjPXXv4Lvw==", - "file_map": { - "50": { - "source": "fn main(x: u8) {\n // This would previously overflow in ACIR. Now it returns zero.\n let value = 1 >> x;\n assert_eq(value, 0);\n}\n", - "path": "" - } - }, + "debug_symbols": "XY5BCsQwCEXv4rqLWfcqw1BsaosgJtikMITefWyYQOlK/3/6tcJCc9km1jXuML4rzMYivE0SA2aO6m49B+hyykbkFty4byU00gyjFpEBDpTShvaE2mpGc/oagHTx6oErC13d+XGBge158UBjnIX+ci0abjR/Uyf942Qx0FKMrqTGPPsH", + "file_map": {}, "names": [ "main" ], - "brillig_names": [ - "directive_integer_quotient", - "directive_to_radix", - "directive_invert" - ] + "brillig_names": [] } diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_0.snap index d22673ddca1..61d871723db 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_0.snap @@ -18,84 +18,20 @@ expression: artifact } ], "return_type": null, - "error_types": { - "5795655218219125583": { - "error_kind": "string", - "string": "Field failed to decompose into specified 8 limbs" - } - } + "error_types": {} }, "bytecode": [ "func 0", - "current witness index : _35", + "current witness index : _0", "private parameters indices : [_0]", "public parameters indices : []", "return value indices : []", - "BLACKBOX::RANGE [(_0, 8)] []", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 224 ], EXPR [ 256 ]], outputs: [_1, _2]", - "BLACKBOX::RANGE [(_1, 1)] []", - "BLACKBOX::RANGE [(_2, 8)] []", - "EXPR [ (1, _0) (-256, _1) (-1, _2) 224 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _1, _0) (1, _0) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_3, _4, _5, _6, _7, _8, _9, _10]]", - "BLACKBOX::RANGE [(_3, 1)] []", - "BLACKBOX::RANGE [(_4, 1)] []", - "BLACKBOX::RANGE [(_5, 1)] []", - "BLACKBOX::RANGE [(_6, 1)] []", - "BLACKBOX::RANGE [(_7, 1)] []", - "BLACKBOX::RANGE [(_8, 1)] []", - "BLACKBOX::RANGE [(_9, 1)] []", - "BLACKBOX::RANGE [(_10, 1)] []", - "EXPR [ (-1, _0, _1) (1, _0) (-1, _3) (-2, _4) (-4, _5) (-8, _6) (-16, _7) (-32, _8) (-64, _9) (-128, _10) 0 ]", - "EXPR [ (1, _10, _10) (2, _10) (-1, _11) 1 ]", - "EXPR [ (-1, _9) (-1, _12) 1 ]", - "EXPR [ (2, _9, _11) (1, _11, _12) (-1, _13) 0 ]", - "EXPR [ (1, _13, _13) (-1, _14) 0 ]", - "EXPR [ (-1, _8) (-1, _15) 1 ]", - "EXPR [ (2, _8, _14) (1, _14, _15) (-1, _16) 0 ]", - "EXPR [ (1, _16, _16) (-1, _17) 0 ]", - "EXPR [ (-1, _7) (-1, _18) 1 ]", - "EXPR [ (2, _7, _17) (1, _17, _18) (-1, _19) 0 ]", - "EXPR [ (1, _19, _19) (-1, _20) 0 ]", - "EXPR [ (-1, _6) (-1, _21) 1 ]", - "EXPR [ (2, _6, _20) (1, _20, _21) (-1, _22) 0 ]", - "EXPR [ (1, _22, _22) (-1, _23) 0 ]", - "EXPR [ (-1, _5) (-1, _24) 1 ]", - "EXPR [ (2, _5, _23) (1, _23, _24) (-1, _25) 0 ]", - "EXPR [ (1, _25, _25) (-1, _26) 0 ]", - "EXPR [ (-1, _4) (-1, _27) 1 ]", - "EXPR [ (2, _4, _26) (1, _26, _27) (-1, _28) 0 ]", - "EXPR [ (1, _28, _28) (-1, _29) 0 ]", - "EXPR [ (-1, _3) (-1, _30) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _29, _3) (1, _29, _30) 0 ]], outputs: [_31]", - "EXPR [ (2, _3, _29) (1, _29, _30) (-1, _32) 0 ]", - "EXPR [ (1, _31, _32) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ 1 ], EXPR [ (1, _32) 0 ]], outputs: [_33, _34]", - "BLACKBOX::RANGE [(_33, 32)] []", - "BLACKBOX::RANGE [(_34, 32)] []", - "EXPR [ (1, _32) (-1, _34) (-1, _35) -1 ]", - "BLACKBOX::RANGE [(_35, 32)] []", - "EXPR [ (-1, _32, _33) (-1, _34) 1 ]", - "EXPR [ (-1, _1, _33) (1, _33) 0 ]", - "unconstrained func 0", - "[Const { destination: Direct(10), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(11), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(10), offset_address: Direct(11) }, BinaryFieldOp { destination: Direct(2), op: IntegerDiv, lhs: Direct(0), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Mul, lhs: Direct(2), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Sub, lhs: Direct(0), rhs: Direct(1) }, Mov { destination: Direct(0), source: Direct(2) }, Stop { return_data: HeapVector { pointer: Direct(11), size: Direct(10) } }]", - "unconstrained func 1", - "[Const { destination: Direct(5), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(6), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(7), bit_size: Integer(U32), value: 3 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(7), offset_address: Direct(5) }, Cast { destination: Direct(1), source: Direct(1), bit_size: Integer(U32) }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(7), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(3), op: IntegerDiv, lhs: Direct(0), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Mul, lhs: Direct(3), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Sub, lhs: Direct(0), rhs: Direct(4) }, Store { destination_pointer: Direct(9), source: Direct(4) }, BinaryIntOp { destination: Direct(9), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(6) }, Mov { destination: Direct(0), source: Direct(3) }, BinaryIntOp { destination: Direct(8), op: LessThan, bit_size: U32, lhs: Direct(9), rhs: Direct(7) }, JumpIf { condition: Direct(8), location: 7 }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, Stop { return_data: HeapVector { pointer: Direct(9), size: Direct(1) } }]", - "unconstrained func 2", - "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" + "BLACKBOX::RANGE [(_0, 8)] []" ], - "debug_symbols": "jdJBboMwEAXQu3jNgpkhTZurVBUyYCJLlkEOVKoQd6+ZD22yiJTNGDz+T9h4MZ1r5mvtYz/czOVzMU3yIfhrHYbWTn6IeXZZC3O81lNyLk+Zu35OjTa5OJlLnEMozLcNsy66jTbqONmUu2VhXOzymMHeB7c9rcV/unwepZL2MJXnv/jp9TzLkRd6yH/lN9v69LBjQ3lhYViraK20nrS+aT1rfdf6oZVKDEgT4oQ8ASAIBIJgEBCCwlB4/wYoDIWhMBSGwlAYCkMRKAJF9q1AESgCRaAIFIEiUCooFZQKSrWfSFZ43c48edsEt1+Vfo7t3c2Zfsajc9ytMQ2t6+bktjPXXv4Lvw==", - "file_map": { - "50": { - "source": "fn main(x: u8) {\n // This would previously overflow in ACIR. Now it returns zero.\n let value = 1 >> x;\n assert_eq(value, 0);\n}\n", - "path": "" - } - }, + "debug_symbols": "XY5BCsQwCEXv4rqLWfcqw1BsaosgJtikMITefWyYQOlK/3/6tcJCc9km1jXuML4rzMYivE0SA2aO6m49B+hyykbkFty4byU00gyjFpEBDpTShvaE2mpGc/oagHTx6oErC13d+XGBge158UBjnIX+ci0abjR/Uyf942Qx0FKMrqTGPPsH", + "file_map": {}, "names": [ "main" ], - "brillig_names": [ - "directive_integer_quotient", - "directive_to_radix", - "directive_invert" - ] + "brillig_names": [] } diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index d22673ddca1..61d871723db 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -18,84 +18,20 @@ expression: artifact } ], "return_type": null, - "error_types": { - "5795655218219125583": { - "error_kind": "string", - "string": "Field failed to decompose into specified 8 limbs" - } - } + "error_types": {} }, "bytecode": [ "func 0", - "current witness index : _35", + "current witness index : _0", "private parameters indices : [_0]", "public parameters indices : []", "return value indices : []", - "BLACKBOX::RANGE [(_0, 8)] []", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 224 ], EXPR [ 256 ]], outputs: [_1, _2]", - "BLACKBOX::RANGE [(_1, 1)] []", - "BLACKBOX::RANGE [(_2, 8)] []", - "EXPR [ (1, _0) (-256, _1) (-1, _2) 224 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _1, _0) (1, _0) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_3, _4, _5, _6, _7, _8, _9, _10]]", - "BLACKBOX::RANGE [(_3, 1)] []", - "BLACKBOX::RANGE [(_4, 1)] []", - "BLACKBOX::RANGE [(_5, 1)] []", - "BLACKBOX::RANGE [(_6, 1)] []", - "BLACKBOX::RANGE [(_7, 1)] []", - "BLACKBOX::RANGE [(_8, 1)] []", - "BLACKBOX::RANGE [(_9, 1)] []", - "BLACKBOX::RANGE [(_10, 1)] []", - "EXPR [ (-1, _0, _1) (1, _0) (-1, _3) (-2, _4) (-4, _5) (-8, _6) (-16, _7) (-32, _8) (-64, _9) (-128, _10) 0 ]", - "EXPR [ (1, _10, _10) (2, _10) (-1, _11) 1 ]", - "EXPR [ (-1, _9) (-1, _12) 1 ]", - "EXPR [ (2, _9, _11) (1, _11, _12) (-1, _13) 0 ]", - "EXPR [ (1, _13, _13) (-1, _14) 0 ]", - "EXPR [ (-1, _8) (-1, _15) 1 ]", - "EXPR [ (2, _8, _14) (1, _14, _15) (-1, _16) 0 ]", - "EXPR [ (1, _16, _16) (-1, _17) 0 ]", - "EXPR [ (-1, _7) (-1, _18) 1 ]", - "EXPR [ (2, _7, _17) (1, _17, _18) (-1, _19) 0 ]", - "EXPR [ (1, _19, _19) (-1, _20) 0 ]", - "EXPR [ (-1, _6) (-1, _21) 1 ]", - "EXPR [ (2, _6, _20) (1, _20, _21) (-1, _22) 0 ]", - "EXPR [ (1, _22, _22) (-1, _23) 0 ]", - "EXPR [ (-1, _5) (-1, _24) 1 ]", - "EXPR [ (2, _5, _23) (1, _23, _24) (-1, _25) 0 ]", - "EXPR [ (1, _25, _25) (-1, _26) 0 ]", - "EXPR [ (-1, _4) (-1, _27) 1 ]", - "EXPR [ (2, _4, _26) (1, _26, _27) (-1, _28) 0 ]", - "EXPR [ (1, _28, _28) (-1, _29) 0 ]", - "EXPR [ (-1, _3) (-1, _30) 1 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (2, _29, _3) (1, _29, _30) 0 ]], outputs: [_31]", - "EXPR [ (2, _3, _29) (1, _29, _30) (-1, _32) 0 ]", - "EXPR [ (1, _31, _32) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ 1 ], EXPR [ (1, _32) 0 ]], outputs: [_33, _34]", - "BLACKBOX::RANGE [(_33, 32)] []", - "BLACKBOX::RANGE [(_34, 32)] []", - "EXPR [ (1, _32) (-1, _34) (-1, _35) -1 ]", - "BLACKBOX::RANGE [(_35, 32)] []", - "EXPR [ (-1, _32, _33) (-1, _34) 1 ]", - "EXPR [ (-1, _1, _33) (1, _33) 0 ]", - "unconstrained func 0", - "[Const { destination: Direct(10), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(11), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(10), offset_address: Direct(11) }, BinaryFieldOp { destination: Direct(2), op: IntegerDiv, lhs: Direct(0), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Mul, lhs: Direct(2), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Sub, lhs: Direct(0), rhs: Direct(1) }, Mov { destination: Direct(0), source: Direct(2) }, Stop { return_data: HeapVector { pointer: Direct(11), size: Direct(10) } }]", - "unconstrained func 1", - "[Const { destination: Direct(5), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(6), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(7), bit_size: Integer(U32), value: 3 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(7), offset_address: Direct(5) }, Cast { destination: Direct(1), source: Direct(1), bit_size: Integer(U32) }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(7), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(3), op: IntegerDiv, lhs: Direct(0), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Mul, lhs: Direct(3), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Sub, lhs: Direct(0), rhs: Direct(4) }, Store { destination_pointer: Direct(9), source: Direct(4) }, BinaryIntOp { destination: Direct(9), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(6) }, Mov { destination: Direct(0), source: Direct(3) }, BinaryIntOp { destination: Direct(8), op: LessThan, bit_size: U32, lhs: Direct(9), rhs: Direct(7) }, JumpIf { condition: Direct(8), location: 7 }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, Stop { return_data: HeapVector { pointer: Direct(9), size: Direct(1) } }]", - "unconstrained func 2", - "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" + "BLACKBOX::RANGE [(_0, 8)] []" ], - "debug_symbols": "jdJBboMwEAXQu3jNgpkhTZurVBUyYCJLlkEOVKoQd6+ZD22yiJTNGDz+T9h4MZ1r5mvtYz/czOVzMU3yIfhrHYbWTn6IeXZZC3O81lNyLk+Zu35OjTa5OJlLnEMozLcNsy66jTbqONmUu2VhXOzymMHeB7c9rcV/unwepZL2MJXnv/jp9TzLkRd6yH/lN9v69LBjQ3lhYViraK20nrS+aT1rfdf6oZVKDEgT4oQ8ASAIBIJgEBCCwlB4/wYoDIWhMBSGwlAYCkMRKAJF9q1AESgCRaAIFIEiUCooFZQKSrWfSFZ43c48edsEt1+Vfo7t3c2Zfsajc9ytMQ2t6+bktjPXXv4Lvw==", - "file_map": { - "50": { - "source": "fn main(x: u8) {\n // This would previously overflow in ACIR. Now it returns zero.\n let value = 1 >> x;\n assert_eq(value, 0);\n}\n", - "path": "" - } - }, + "debug_symbols": "XY5BCsQwCEXv4rqLWfcqw1BsaosgJtikMITefWyYQOlK/3/6tcJCc9km1jXuML4rzMYivE0SA2aO6m49B+hyykbkFty4byU00gyjFpEBDpTShvaE2mpGc/oagHTx6oErC13d+XGBge158UBjnIX+ci0abjR/Uyf942Qx0FKMrqTGPPsH", + "file_map": {}, "names": [ "main" ], - "brillig_names": [ - "directive_integer_quotient", - "directive_to_radix", - "directive_invert" - ] + "brillig_names": [] } diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index f0be642a65d..c12223698e8 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -33,15 +33,10 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 23 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 22 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 28 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 16 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 21 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "jZBNCoMwEEbvMussEovVehURiTpKIESJSaFI7t6JP60uCt3kZTJ538As0GHjh1qZfpyhKBdorNJaDbUeW+nUaOh1AR4PkUIhGIj7hgyKhJBveKxI+AZBCIHBEVI7ixgzTqk0a5IWjYPCeK0ZPKX266d5kmalk5a6nAGajkiBvdIYb4F9bf5bFVzssuDZR0//95Pb4d/Exa+okq2ylz2FmGSVbDTuZe9Ne+q613R0jj1Pdmyx8xZj0mnZdJY0PcmrEKe9AQ==", - "file_map": { - "50": { - "source": "fn main(x: u8) {\n // This would previously overflow in ACIR. Now it returns zero.\n let value = 1 >> x;\n assert_eq(value, 0);\n}\n", - "path": "" - } - }, + "debug_symbols": "XY7BCoRACIbfxfMcag976FUiwiaLAXEGmwmW6N3XiQ1iL+rvp/4eMNNU1jHIEjfo+gMmDcxhHTl6zCGKdY/TwS3HrETWgge3rYRKkqGTwuxgRy7X0JZQrpxRjTYOSGbLdnAJTLU6BxPog/477qgBJ6afXIr4B82fdJP746TR01yU6qXKoKmhtdi3b/dqh7O6fQE=", + "file_map": {}, "names": [ "main" ], diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_true_inliner_0.snap index f0be642a65d..c12223698e8 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_true_inliner_0.snap @@ -33,15 +33,10 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 23 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 22 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 28 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 16 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 21 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "jZBNCoMwEEbvMussEovVehURiTpKIESJSaFI7t6JP60uCt3kZTJ538As0GHjh1qZfpyhKBdorNJaDbUeW+nUaOh1AR4PkUIhGIj7hgyKhJBveKxI+AZBCIHBEVI7ixgzTqk0a5IWjYPCeK0ZPKX266d5kmalk5a6nAGajkiBvdIYb4F9bf5bFVzssuDZR0//95Pb4d/Exa+okq2ylz2FmGSVbDTuZe9Ne+q613R0jj1Pdmyx8xZj0mnZdJY0PcmrEKe9AQ==", - "file_map": { - "50": { - "source": "fn main(x: u8) {\n // This would previously overflow in ACIR. Now it returns zero.\n let value = 1 >> x;\n assert_eq(value, 0);\n}\n", - "path": "" - } - }, + "debug_symbols": "XY7BCoRACIbfxfMcag976FUiwiaLAXEGmwmW6N3XiQ1iL+rvp/4eMNNU1jHIEjfo+gMmDcxhHTl6zCGKdY/TwS3HrETWgge3rYRKkqGTwuxgRy7X0JZQrpxRjTYOSGbLdnAJTLU6BxPog/477qgBJ6afXIr4B82fdJP746TR01yU6qXKoKmhtdi3b/dqh7O6fQE=", + "file_map": {}, "names": [ "main" ], diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index f0be642a65d..c12223698e8 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -33,15 +33,10 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 23 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 22 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 28 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 16 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 21 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "jZBNCoMwEEbvMussEovVehURiTpKIESJSaFI7t6JP60uCt3kZTJ538As0GHjh1qZfpyhKBdorNJaDbUeW+nUaOh1AR4PkUIhGIj7hgyKhJBveKxI+AZBCIHBEVI7ixgzTqk0a5IWjYPCeK0ZPKX266d5kmalk5a6nAGajkiBvdIYb4F9bf5bFVzssuDZR0//95Pb4d/Exa+okq2ylz2FmGSVbDTuZe9Ne+q613R0jj1Pdmyx8xZj0mnZdJY0PcmrEKe9AQ==", - "file_map": { - "50": { - "source": "fn main(x: u8) {\n // This would previously overflow in ACIR. Now it returns zero.\n let value = 1 >> x;\n assert_eq(value, 0);\n}\n", - "path": "" - } - }, + "debug_symbols": "XY7BCoRACIbfxfMcag976FUiwiaLAXEGmwmW6N3XiQ1iL+rvp/4eMNNU1jHIEjfo+gMmDcxhHTl6zCGKdY/TwS3HrETWgge3rYRKkqGTwuxgRy7X0JZQrpxRjTYOSGbLdnAJTLU6BxPog/477qgBJ6afXIr4B82fdJP746TR01yU6qXKoKmhtdi3b/dqh7O6fQE=", + "file_map": {}, "names": [ "main" ], diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__expanded.snap new file mode 100644 index 00000000000..e4aa2c16393 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__expanded.snap @@ -0,0 +1,12 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: expanded_code +--- +fn main() { + for idx_d in 0_u32..1_u32 { + if idx_d == 2_u32 { + let a: i32 = 345422577_i32 >> -115035501_i32; + let _: i32 = 1_i32 >> a; + } + } +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..7de940827c8 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -0,0 +1,26 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": null, + "error_types": {} + }, + "bytecode": [ + "func 0", + "current witness index : _0", + "private parameters indices : []", + "public parameters indices : []", + "return value indices : []" + ], + "debug_symbols": "XY5BCsQwCEXv4rqLWfcqw1BsaosgJtikMITefWyYQOlK/3/6tcJCc9km1jXuML4rzMYivE0SA2aO6m49B+hyykbkFty4byU00gyjFpEBDpTShvaE2mpGc/oagHTx6oErC13d+XGBge158UBjnIX+ci0abjR/Uyf942Qx0FKMrqTGPPsH", + "file_map": {}, + "names": [ + "main" + ], + "brillig_names": [] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_false_inliner_0.snap new file mode 100644 index 00000000000..7de940827c8 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_false_inliner_0.snap @@ -0,0 +1,26 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": null, + "error_types": {} + }, + "bytecode": [ + "func 0", + "current witness index : _0", + "private parameters indices : []", + "public parameters indices : []", + "return value indices : []" + ], + "debug_symbols": "XY5BCsQwCEXv4rqLWfcqw1BsaosgJtikMITefWyYQOlK/3/6tcJCc9km1jXuML4rzMYivE0SA2aO6m49B+hyykbkFty4byU00gyjFpEBDpTShvaE2mpGc/oagHTx6oErC13d+XGBge158UBjnIX+ci0abjR/Uyf942Qx0FKMrqTGPPsH", + "file_map": {}, + "names": [ + "main" + ], + "brillig_names": [] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_false_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..7de940827c8 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -0,0 +1,26 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": null, + "error_types": {} + }, + "bytecode": [ + "func 0", + "current witness index : _0", + "private parameters indices : []", + "public parameters indices : []", + "return value indices : []" + ], + "debug_symbols": "XY5BCsQwCEXv4rqLWfcqw1BsaosgJtikMITefWyYQOlK/3/6tcJCc9km1jXuML4rzMYivE0SA2aO6m49B+hyykbkFty4byU00gyjFpEBDpTShvaE2mpGc/oagHTx6oErC13d+XGBge158UBjnIX+ci0abjR/Uyf942Qx0FKMrqTGPPsH", + "file_map": {}, + "names": [ + "main" + ], + "brillig_names": [] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..41e0c42011c --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -0,0 +1,36 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": null, + "error_types": { + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": [ + "func 0", + "current witness index : _0", + "private parameters indices : []", + "public parameters indices : []", + "return value indices : []", + "BRILLIG CALL func 0: inputs: [], outputs: []", + "unconstrained func 0", + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32836 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(1), offset_address: Relative(2) }, Call { location: 11 }, Call { location: 12 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32836 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 14 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 19 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + ], + "debug_symbols": "XY7BCoRACIbfxfMcCvayvUpE2GQxIM5gM8ESvfs6sUHsRf391N8DZprKOgZZ4gZdf8CkgTmsI0ePOUSx7nE6uOWYlcha8OC2lVBJMnRSmB3syOUa2hLKlTOq0cYByWzZDi6BqVbnYAJ90H/HHTXgxPSTSxH/oPmTbnJ/nDR6motSvVQZNDW0Fvv25dr3cFa3Lw==", + "file_map": {}, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_true_inliner_0.snap new file mode 100644 index 00000000000..41e0c42011c --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_true_inliner_0.snap @@ -0,0 +1,36 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": null, + "error_types": { + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": [ + "func 0", + "current witness index : _0", + "private parameters indices : []", + "public parameters indices : []", + "return value indices : []", + "BRILLIG CALL func 0: inputs: [], outputs: []", + "unconstrained func 0", + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32836 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(1), offset_address: Relative(2) }, Call { location: 11 }, Call { location: 12 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32836 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 14 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 19 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + ], + "debug_symbols": "XY7BCoRACIbfxfMcCvayvUpE2GQxIM5gM8ESvfs6sUHsRf391N8DZprKOgZZ4gZdf8CkgTmsI0ePOUSx7nE6uOWYlcha8OC2lVBJMnRSmB3syOUa2hLKlTOq0cYByWzZDi6BqVbnYAJ90H/HHTXgxPSTSxH/oPmTbnJ/nDR6motSvVQZNDW0Fvv25dr3cFa3Lw==", + "file_map": {}, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_true_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..41e0c42011c --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -0,0 +1,36 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": null, + "error_types": { + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": [ + "func 0", + "current witness index : _0", + "private parameters indices : []", + "public parameters indices : []", + "return value indices : []", + "BRILLIG CALL func 0: inputs: [], outputs: []", + "unconstrained func 0", + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32836 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(1), offset_address: Relative(2) }, Call { location: 11 }, Call { location: 12 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32836 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 14 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 19 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + ], + "debug_symbols": "XY7BCoRACIbfxfMcCvayvUpE2GQxIM5gM8ESvfs6sUHsRf391N8DZprKOgZZ4gZdf8CkgTmsI0ePOUSx7nE6uOWYlcha8OC2lVBJMnRSmB3syOUa2hLKlTOq0cYByWzZDi6BqVbnYAJ90H/HHTXgxPSTSxH/oPmTbnJ/nDR6motSvVQZNDW0Fvv25dr3cFa3Lw==", + "file_map": {}, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__stdout.snap b/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__stdout.snap new file mode 100644 index 00000000000..e86e3de90e1 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/signed_bitshift/execute__tests__stdout.snap @@ -0,0 +1,5 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: stdout +--- + diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/simple_shift_left_right/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/execution_success/simple_shift_left_right/execute__tests__expanded.snap index 17db14707fb..80aa4b9c812 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/simple_shift_left_right/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/simple_shift_left_right/execute__tests__expanded.snap @@ -3,7 +3,7 @@ source: tooling/nargo_cli/tests/execute.rs expression: expanded_code --- fn main(x: u32) { - let z: u32 = x >> 4_u8; - let t: u32 = x << 4_u8; - assert(z == (t >> 8_u8)); + let z: u32 = x >> 4_u32; + let t: u32 = x << 4_u32; + assert(z == (t >> 8_u32)); } diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/simple_shift_left_right/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/simple_shift_left_right/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 89a824e6fd0..a09c084318a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/simple_shift_left_right/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/simple_shift_left_right/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -33,7 +33,7 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 4 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 24 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 30 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 24 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 30 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], "debug_symbols": "nZHBroMgEEX/ZdYsALW+x680jUEdGxKChkKTxvDvHbS2dtGk6YYDzJw7i5mhxzaeG+OG8QLqOEPrjbXm3Nix08GMjn5n4PkQFSjBQBxW1KAk4Q9UQfhfIKmxJIgVckVBSInBFtkEj5gTdzNo8qQ9ugDKRWsZXLWNS9Nl0m5h0J6qnAG6nkiBg7GYb4m9bP5ZFVI8ZCHrp15975dPv/zJP1SbX4uffP7BP9FLd8a/bS3lJG90a/HxHKLrdtVwm7bKtvXJjx320WNO2q2ezqOsWMFPKU+7Aw==", "file_map": { diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/simple_shift_left_right/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/simple_shift_left_right/execute__tests__force_brillig_true_inliner_0.snap index 89a824e6fd0..a09c084318a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/simple_shift_left_right/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/simple_shift_left_right/execute__tests__force_brillig_true_inliner_0.snap @@ -33,7 +33,7 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 4 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 24 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 30 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 24 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 30 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], "debug_symbols": "nZHBroMgEEX/ZdYsALW+x680jUEdGxKChkKTxvDvHbS2dtGk6YYDzJw7i5mhxzaeG+OG8QLqOEPrjbXm3Nix08GMjn5n4PkQFSjBQBxW1KAk4Q9UQfhfIKmxJIgVckVBSInBFtkEj5gTdzNo8qQ9ugDKRWsZXLWNS9Nl0m5h0J6qnAG6nkiBg7GYb4m9bP5ZFVI8ZCHrp15975dPv/zJP1SbX4uffP7BP9FLd8a/bS3lJG90a/HxHKLrdtVwm7bKtvXJjx320WNO2q2ezqOsWMFPKU+7Aw==", "file_map": { diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/simple_shift_left_right/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/simple_shift_left_right/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 89a824e6fd0..a09c084318a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/simple_shift_left_right/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/simple_shift_left_right/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -33,7 +33,7 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 4 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 8 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 24 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 30 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 25 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(3), op: Shr, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 24 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 30 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], "debug_symbols": "nZHBroMgEEX/ZdYsALW+x680jUEdGxKChkKTxvDvHbS2dtGk6YYDzJw7i5mhxzaeG+OG8QLqOEPrjbXm3Nix08GMjn5n4PkQFSjBQBxW1KAk4Q9UQfhfIKmxJIgVckVBSInBFtkEj5gTdzNo8qQ9ugDKRWsZXLWNS9Nl0m5h0J6qnAG6nkiBg7GYb4m9bP5ZFVI8ZCHrp15975dPv/zJP1SbX4uffP7BP9FLd8a/bS3lJG90a/HxHKLrdtVwm7bKtvXJjx320WNO2q2ezqOsWMFPKU+7Aw==", "file_map": { diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__expanded.snap index 23e9e834b7e..b2d2eca4672 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__expanded.snap @@ -2,10 +2,10 @@ source: tooling/nargo_cli/tests/execute.rs expression: expanded_code --- -fn main(x: u128, y: u128, z: u8) { +fn main(x: u128, y: u128, z: u128) { let const_x: u128 = 12345_u128; let const_y: u128 = 2345678_u128; - let const_z: u8 = 2_u8; + let const_z: u128 = 2_u128; assert((x + y) == (const_x + const_y)); assert((y - x) == (const_y - const_x)); assert((x * y) == (const_x * const_y)); diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index e70503d30fc..02777802acb 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -30,7 +30,7 @@ expression: artifact "type": { "kind": "integer", "sign": "unsigned", - "width": 8 + "width": 128 }, "visibility": "private" } @@ -61,12 +61,12 @@ expression: artifact }, "bytecode": [ "func 0", - "current witness index : _114", + "current witness index : _84", "private parameters indices : [_0, _1, _2]", "public parameters indices : []", "return value indices : []", "BLACKBOX::RANGE [(_1, 128)] []", - "BLACKBOX::RANGE [(_2, 8)] []", + "BLACKBOX::RANGE [(_2, 128)] []", "EXPR [ (1, _0) (1, _1) -2358023 ]", "EXPR [ (-1, _0) (1, _1) -2333333 ]", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_6, _7]", @@ -122,12 +122,13 @@ expression: artifact "EXPR [ (-1, _1) (-1, _29) 340282366920938463463374607431768211455 ]", "BLACKBOX::AND [(_28, 128), (_29, 128)] [_30]", "EXPR [ (-1, _30) 340282366920938463463374607431765853440 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 128 ], EXPR [ 256 ]], outputs: [_31, _32]", - "BLACKBOX::RANGE [(_31, 1)] []", - "BLACKBOX::RANGE [(_32, 8)] []", - "EXPR [ (1, _2) (-256, _31) (-1, _32) 128 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _31, _2) (1, _2) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_33, _34, _35, _36, _37, _38, _39, _40]]", - "BLACKBOX::RANGE [(_33, 1)] []", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 340282366920938463463374607431768211328 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_31, _32]", + "BLACKBOX::RANGE [(_32, 129)] []", + "EXPR [ (-1, _32) (-1, _33) 340282366920938463463374607431768211455 ]", + "BLACKBOX::RANGE [(_33, 129)] []", + "EXPR [ (1, _2) (-340282366920938463463374607431768211456, _31) (-1, _32) 340282366920938463463374607431768211328 ]", + "EXPR [ (-1, _31) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_34, _35, _36, _37, _38, _39, _40, _41]]", "BLACKBOX::RANGE [(_34, 1)] []", "BLACKBOX::RANGE [(_35, 1)] []", "BLACKBOX::RANGE [(_36, 1)] []", @@ -135,107 +136,73 @@ expression: artifact "BLACKBOX::RANGE [(_38, 1)] []", "BLACKBOX::RANGE [(_39, 1)] []", "BLACKBOX::RANGE [(_40, 1)] []", - "EXPR [ (-1, _2, _31) (1, _2) (-1, _33) (-2, _34) (-4, _35) (-8, _36) (-16, _37) (-32, _38) (-64, _39) (-128, _40) 0 ]", - "EXPR [ (1, _40, _40) (2, _40) (-1, _41) 1 ]", - "EXPR [ (-1, _39) (-1, _42) 1 ]", - "EXPR [ (2, _39, _41) (1, _41, _42) (-1, _43) 0 ]", - "EXPR [ (1, _43, _43) (-1, _44) 0 ]", - "EXPR [ (-1, _38) (-1, _45) 1 ]", - "EXPR [ (2, _38, _44) (1, _44, _45) (-1, _46) 0 ]", - "EXPR [ (1, _46, _46) (-1, _47) 0 ]", - "EXPR [ (-1, _37) (-1, _48) 1 ]", - "EXPR [ (2, _37, _47) (1, _47, _48) (-1, _49) 0 ]", - "EXPR [ (1, _49, _49) (-1, _50) 0 ]", - "EXPR [ (-1, _36) (-1, _51) 1 ]", - "EXPR [ (2, _36, _50) (1, _50, _51) (-1, _52) 0 ]", - "EXPR [ (1, _52, _52) (-1, _53) 0 ]", - "EXPR [ (-1, _35) (-1, _54) 1 ]", - "EXPR [ (2, _35, _53) (1, _53, _54) (-1, _55) 0 ]", - "EXPR [ (1, _55, _55) (-1, _56) 0 ]", - "EXPR [ (-1, _34) (-1, _57) 1 ]", - "EXPR [ (2, _34, _56) (1, _56, _57) (-1, _58) 0 ]", - "EXPR [ (1, _58, _58) (-1, _59) 0 ]", - "EXPR [ (-1, _33) (-1, _60) 1 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (2, _59, _33) (1, _59, _60) 0 ]], outputs: [_61]", - "EXPR [ (2, _33, _59) (1, _59, _60) (-1, _62) 0 ]", - "EXPR [ (1, _61, _62) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _62) 0 ]], outputs: [_63, _64]", - "BLACKBOX::RANGE [(_63, 128)] []", - "BLACKBOX::RANGE [(_64, 128)] []", - "EXPR [ (1, _62) (-1, _64) (-1, _65) -1 ]", + "BLACKBOX::RANGE [(_41, 1)] []", + "EXPR [ (1, _2) (-1, _34) (-2, _35) (-4, _36) (-8, _37) (-16, _38) (-32, _39) (-64, _40) (-128, _41) 0 ]", + "EXPR [ (1, _41, _41) (2, _41) (-1, _42) 1 ]", + "EXPR [ (-1, _40) (-1, _43) 1 ]", + "EXPR [ (2, _40, _42) (1, _42, _43) (-1, _44) 0 ]", + "EXPR [ (1, _44, _44) (-1, _45) 0 ]", + "EXPR [ (-1, _39) (-1, _46) 1 ]", + "EXPR [ (2, _39, _45) (1, _45, _46) (-1, _47) 0 ]", + "EXPR [ (1, _47, _47) (-1, _48) 0 ]", + "EXPR [ (-1, _38) (-1, _49) 1 ]", + "EXPR [ (2, _38, _48) (1, _48, _49) (-1, _50) 0 ]", + "EXPR [ (1, _50, _50) (-1, _51) 0 ]", + "EXPR [ (-1, _37) (-1, _52) 1 ]", + "EXPR [ (2, _37, _51) (1, _51, _52) (-1, _53) 0 ]", + "EXPR [ (1, _53, _53) (-1, _54) 0 ]", + "EXPR [ (-1, _36) (-1, _55) 1 ]", + "EXPR [ (2, _36, _54) (1, _54, _55) (-1, _56) 0 ]", + "EXPR [ (1, _56, _56) (-1, _57) 0 ]", + "EXPR [ (-1, _35) (-1, _58) 1 ]", + "EXPR [ (2, _35, _57) (1, _57, _58) (-1, _59) 0 ]", + "EXPR [ (1, _59, _59) (-1, _60) 0 ]", + "EXPR [ (-1, _34) (-1, _61) 1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (2, _60, _34) (1, _60, _61) 0 ]], outputs: [_62]", + "EXPR [ (2, _34, _60) (1, _60, _61) (-1, _63) 0 ]", + "EXPR [ (1, _62, _63) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _63) 0 ]], outputs: [_64, _65]", "BLACKBOX::RANGE [(_65, 128)] []", - "EXPR [ (-1, _62, _63) (1, _0) (-1, _64) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _63) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_66, _67]", - "BLACKBOX::RANGE [(_66, 64)] []", + "EXPR [ (1, _63) (-1, _65) (-1, _66) -1 ]", + "BLACKBOX::RANGE [(_66, 128)] []", + "EXPR [ (-1, _63, _64) (1, _0) (-1, _65) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _64) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_67, _68]", "BLACKBOX::RANGE [(_67, 64)] []", - "EXPR [ (1, _63) (-18446744073709551616, _66) (-1, _67) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _62) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_68, _69]", "BLACKBOX::RANGE [(_68, 64)] []", + "EXPR [ (1, _64) (-18446744073709551616, _67) (-1, _68) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _63) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_69, _70]", "BLACKBOX::RANGE [(_69, 64)] []", - "EXPR [ (1, _62) (-18446744073709551616, _68) (-1, _69) 0 ]", - "EXPR [ (1, _66, _68) 0 ]", - "EXPR [ (-1, _31, _63) (1, _63) -3086 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_70, _71, _72, _73, _74, _75, _76, _77]]", - "BLACKBOX::RANGE [(_70, 1)] []", - "BLACKBOX::RANGE [(_71, 1)] []", - "BLACKBOX::RANGE [(_72, 1)] []", - "BLACKBOX::RANGE [(_73, 1)] []", - "BLACKBOX::RANGE [(_74, 1)] []", - "BLACKBOX::RANGE [(_75, 1)] []", - "BLACKBOX::RANGE [(_76, 1)] []", - "BLACKBOX::RANGE [(_77, 1)] []", - "EXPR [ (1, _2) (-1, _70) (-2, _71) (-4, _72) (-8, _73) (-16, _74) (-32, _75) (-64, _76) (-128, _77) 0 ]", - "EXPR [ (1, _77, _77) (2, _77) (-1, _78) 1 ]", - "EXPR [ (-1, _76) (-1, _79) 1 ]", - "EXPR [ (2, _76, _78) (1, _78, _79) (-1, _80) 0 ]", - "EXPR [ (1, _80, _80) (-1, _81) 0 ]", - "EXPR [ (-1, _75) (-1, _82) 1 ]", - "EXPR [ (2, _75, _81) (1, _81, _82) (-1, _83) 0 ]", - "EXPR [ (1, _83, _83) (-1, _84) 0 ]", - "EXPR [ (-1, _74) (-1, _85) 1 ]", - "EXPR [ (2, _74, _84) (1, _84, _85) (-1, _86) 0 ]", - "EXPR [ (1, _86, _86) (-1, _87) 0 ]", - "EXPR [ (-1, _73) (-1, _88) 1 ]", - "EXPR [ (2, _73, _87) (1, _87, _88) (-1, _89) 0 ]", - "EXPR [ (1, _89, _89) (-1, _90) 0 ]", - "EXPR [ (-1, _72) (-1, _91) 1 ]", - "EXPR [ (2, _72, _90) (1, _90, _91) (-1, _92) 0 ]", - "EXPR [ (1, _92, _92) (-1, _93) 0 ]", - "EXPR [ (-1, _71) (-1, _94) 1 ]", - "EXPR [ (2, _71, _93) (1, _93, _94) (-1, _95) 0 ]", - "EXPR [ (1, _95, _95) (-1, _96) 0 ]", - "EXPR [ (-1, _70) (-1, _97) 1 ]", - "EXPR [ (-1, _31) (-1, _98) 1 ]", - "EXPR [ (2, _70, _96) (1, _96, _97) (-1, _99) 0 ]", - "EXPR [ (1, _98, _99) (-1, _100) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0, _100) 0 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_101, _102]", - "BLACKBOX::RANGE [(_101, 126)] []", - "EXPR [ (-1, _102) (-1, _103) 340282366920938463463374607431768211455 ]", - "BLACKBOX::RANGE [(_103, 129)] []", - "EXPR [ (1, _0, _100) (-340282366920938463463374607431768211456, _101) (-1, _102) 0 ]", - "EXPR [ (1, _101) (-1, _104) 20746827117051438823981594372716013474 ]", - "BLACKBOX::RANGE [(_104, 126)] []", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _101) 64323764613183177041862057485226039389 ]], outputs: [_105]", - "EXPR [ (-1, _101, _105) (64323764613183177041862057485226039389, _105) (1, _106) -1 ]", - "EXPR [ (-1, _101, _106) (64323764613183177041862057485226039389, _106) 0 ]", - "EXPR [ (-1, _102, _106) (53438638232309528389504892708671455233, _106) (-1, _107) 0 ]", - "BLACKBOX::RANGE [(_107, 129)] []", - "EXPR [ (1, _98) -1 ]", - "EXPR [ (1, _102) -49380 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) (-1, _1) 340282366920938463463374607431768211456 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_108, _109]", - "BLACKBOX::RANGE [(_109, 129)] []", - "EXPR [ (-1, _109) (-1, _110) 340282366920938463463374607431768211455 ]", - "BLACKBOX::RANGE [(_110, 129)] []", - "EXPR [ (1, _0) (-1, _1) (-340282366920938463463374607431768211456, _108) (-1, _109) 340282366920938463463374607431768211456 ]", - "EXPR [ (-1, _108) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _0) (1, _1) 340282366920938463463374607431768211456 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_111, _112]", - "BLACKBOX::RANGE [(_112, 129)] []", - "EXPR [ (-1, _112) (-1, _113) 340282366920938463463374607431768211455 ]", - "BLACKBOX::RANGE [(_113, 129)] []", - "EXPR [ (-1, _0) (1, _1) (-340282366920938463463374607431768211456, _111) (-1, _112) 340282366920938463463374607431768211456 ]", - "EXPR [ (-1, _111) 1 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) (-1, _1) 0 ]], outputs: [_114]", - "EXPR [ (1, _0, _114) (-1, _1, _114) -1 ]", + "BLACKBOX::RANGE [(_70, 64)] []", + "EXPR [ (1, _63) (-18446744073709551616, _69) (-1, _70) 0 ]", + "EXPR [ (1, _67, _69) 0 ]", + "EXPR [ (1, _64) -3086 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0, _63) 0 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_71, _72]", + "BLACKBOX::RANGE [(_71, 126)] []", + "EXPR [ (-1, _72) (-1, _73) 340282366920938463463374607431768211455 ]", + "BLACKBOX::RANGE [(_73, 129)] []", + "EXPR [ (1, _0, _63) (-340282366920938463463374607431768211456, _71) (-1, _72) 0 ]", + "EXPR [ (1, _71) (-1, _74) 20746827117051438823981594372716013474 ]", + "BLACKBOX::RANGE [(_74, 126)] []", + "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _71) 64323764613183177041862057485226039389 ]], outputs: [_75]", + "EXPR [ (-1, _71, _75) (64323764613183177041862057485226039389, _75) (1, _76) -1 ]", + "EXPR [ (-1, _71, _76) (64323764613183177041862057485226039389, _76) 0 ]", + "EXPR [ (-1, _72, _76) (53438638232309528389504892708671455233, _76) (-1, _77) 0 ]", + "BLACKBOX::RANGE [(_77, 129)] []", + "EXPR [ (1, _72) -49380 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) (-1, _1) 340282366920938463463374607431768211456 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_78, _79]", + "BLACKBOX::RANGE [(_79, 129)] []", + "EXPR [ (-1, _79) (-1, _80) 340282366920938463463374607431768211455 ]", + "BLACKBOX::RANGE [(_80, 129)] []", + "EXPR [ (1, _0) (-1, _1) (-340282366920938463463374607431768211456, _78) (-1, _79) 340282366920938463463374607431768211456 ]", + "EXPR [ (-1, _78) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _0) (1, _1) 340282366920938463463374607431768211456 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_81, _82]", + "BLACKBOX::RANGE [(_82, 129)] []", + "EXPR [ (-1, _82) (-1, _83) 340282366920938463463374607431768211455 ]", + "BLACKBOX::RANGE [(_83, 129)] []", + "EXPR [ (-1, _0) (1, _1) (-340282366920938463463374607431768211456, _81) (-1, _82) 340282366920938463463374607431768211456 ]", + "EXPR [ (-1, _81) 1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) (-1, _1) 0 ]], outputs: [_84]", + "EXPR [ (1, _0, _84) (-1, _1, _84) -1 ]", "unconstrained func 0", "[Const { destination: Direct(10), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(11), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(10), offset_address: Direct(11) }, BinaryFieldOp { destination: Direct(2), op: IntegerDiv, lhs: Direct(0), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Mul, lhs: Direct(2), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Sub, lhs: Direct(0), rhs: Direct(1) }, Mov { destination: Direct(0), source: Direct(2) }, Stop { return_data: HeapVector { pointer: Direct(11), size: Direct(10) } }]", "unconstrained func 1", @@ -243,10 +210,10 @@ expression: artifact "unconstrained func 2", "[Const { destination: Direct(5), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(6), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(7), bit_size: Integer(U32), value: 3 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(7), offset_address: Direct(5) }, Cast { destination: Direct(1), source: Direct(1), bit_size: Integer(U32) }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(7), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(3), op: IntegerDiv, lhs: Direct(0), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Mul, lhs: Direct(3), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Sub, lhs: Direct(0), rhs: Direct(4) }, Store { destination_pointer: Direct(9), source: Direct(4) }, BinaryIntOp { destination: Direct(9), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(6) }, Mov { destination: Direct(0), source: Direct(3) }, BinaryIntOp { destination: Direct(8), op: LessThan, bit_size: U32, lhs: Direct(9), rhs: Direct(7) }, JumpIf { condition: Direct(8), location: 7 }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, Stop { return_data: HeapVector { pointer: Direct(9), size: Direct(1) } }]" ], - "debug_symbols": "pdfLTuNAEAXQf/E6C3dV9YtfGY2QCQZFspLIJEgjxL9PtasuA4vZtDe+N486dBw/yMfwPD/dXx9P55fL2/Dw62N4Wk/Lcnp9XC7H6Xa6nPXZj8/DgIePt3We9anh2+s6dZ3W+XwbHs73ZTkM79Ny3970dp3OW96mVV8dD8N8ftZU8OW0zK19Hv5Nj/8fDcQ+HKh8jceeeck980kwn+q++dKzfhqjz1MY981Tz/pJEuZj2Defu9ZfMuYr7Zrn0LN+poJ56Vk/x6+/n2jffOlaf8X6ZeR989SzfuGKeZF986ln/VJw8ZGSds3HsWc+fl1/Ytf5921euuYTzr+Yw7752nP8pxHHbwq8b5675iO+v5R/fn+/9dF0PK0/7ngD6SXjMLB+8YdB9I2HIW7btG3zti3btm7bMFoEC7LQed1tQQFdfYgWySJbFIu6BY0WwYIs2MIUMoVMIVPIFDKFVdGzlVXRk4bJgi3EIloki2xRLOoWMlqYIqaIKWKKmCKmiCpB97IoE4Jmbbdd3XEKBT16Y2g3X02lQtuh3G6LmuIZPZUL+jFi8/RzxOJZLdPoGTzJkz3FM3omT/eSe8m97F52L7uX3cvuZfeye9m97F52r7hX3CvuFfeKe8W94l5xr7hX3KvuVfeqe9W96l51r7pX3avuVffCOKIEFEJhFEGJKAkloxSUJtd29I/tP41WAgqhMIqgRJSEklEKSvVCkAkyQSbIBJkgE2SCTJAJMkNmyAyZITNkhsyQGTJDZsgCWSALZIEskAWyQBbIAlkgR8gRcoQcIUfIEXI7sSi00mRqpaBUL+3kshJQmsytNFlaEZSIklAySpPbJbCdZdQugu00o3bpfZ/W0/S0zP7L4uV+Pn77oXH7c8Ur+ClyXS/H+fm+zu0Svb2mF+2/", + "debug_symbols": "pZbNbqswEIXfhTULezz+66tcXVUkIRUSIhFNKl1Fffc7w8y06aIbs+E7CTlfXcA2j+40Hu5vr9Nyvrx3L38e3WGd5nl6e50vx+E2XRb69vHZd/bx9baOI33VPZ2n1nVYx+XWvSz3ee67j2G+bz96vw7Lxtuw0lnXd+NyIpLwPM0jp8/+u+1+r3qIWvbhux5b+lhb+ilZP/t9/doyfnBZ++BhXz+0jB+wWD+Gff3cNP5SrV9xVz/4lvGHYA9vwJbxh/j19xPu65eW8aOz8aOL+/rQMn5Eb31M+/qpafwFrF/Krn50Lf34tf7Epvn31I9N/WTzL+awr19bnv/k7PlNPu7rh6Z+tPuX8s/795c+Dcdp/bHjdUBLRt8FuvF9h/TDvovbMW3HvB3Ldqzb0TuBF4CA+rTsexLQ6uujIAmyoAjqBnACLwBBEIgFxAJiAbGAWEAsgSx0twJZ6KIFEAQBCqIgCbKgCOoGdAKxoFhQLCgWFAuKBcni6RYgaTzNVqy87dKFc7xpEz1vvkRSeb6ggbdFIiqjMvEmS2Qf/R+xKKswOaVXgjIoURmVSam+pL6kvqy+rL6svqy+rL6svqy+rL6svqy+or6ivqK+or6ivqK+or6ivqK+or6qvqq+qr6qvqq+qr6qvqq+qr6qPu+cBW8BLAQLaCFaSBayhWLBzDwLfOXg+ZWDA1gIFtBCtJAsZAvFQtXAM0OCmcHMPD/Ac2AzcIgWkoVsoVhgc+A5ymbk4C2AhWABLbB5m9ls5rnNcwd4R/sY1mk4zKO+MJ/vy/Hp/fn272pn7A37ul6O4+m+jrzybOdoLfoP", "file_map": { "50": { - "source": "fn main(x: u128, y: u128, z: u8) {\n let const_x = 12345;\n let const_y = 2345678;\n let const_z = 2;\n\n assert_eq(x + y, const_x + const_y);\n assert_eq(y - x, const_y - const_x);\n assert_eq(x * y, const_x * const_y);\n assert_eq(y / x, const_y / const_x);\n assert_eq(y % x, const_y % const_x);\n assert_eq(!x, !const_x);\n assert_eq(x ^ y, const_x ^ const_y);\n assert_eq(x & y, const_x & const_y);\n assert_eq(x | y, const_x | const_y);\n assert_eq(x >> z, const_x >> const_z);\n assert_eq(x << z, const_x << const_z);\n assert_eq(x < y, const_x < const_y);\n assert_eq(x <= y, const_x <= const_y);\n assert_eq(x != y, const_x != const_y);\n assert_eq(y > x, const_y > const_x);\n assert_eq(y >= x, const_y >= const_x);\n}\n", + "source": "fn main(x: u128, y: u128, z: u128) {\n let const_x = 12345;\n let const_y = 2345678;\n let const_z = 2;\n\n assert_eq(x + y, const_x + const_y);\n assert_eq(y - x, const_y - const_x);\n assert_eq(x * y, const_x * const_y);\n assert_eq(y / x, const_y / const_x);\n assert_eq(y % x, const_y % const_x);\n assert_eq(!x, !const_x);\n assert_eq(x ^ y, const_x ^ const_y);\n assert_eq(x & y, const_x & const_y);\n assert_eq(x | y, const_x | const_y);\n assert_eq(x >> z, const_x >> const_z);\n assert_eq(x << z, const_x << const_z);\n assert_eq(x < y, const_x < const_y);\n assert_eq(x <= y, const_x <= const_y);\n assert_eq(x != y, const_x != const_y);\n assert_eq(y > x, const_y > const_x);\n assert_eq(y >= x, const_y >= const_x);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_0.snap index e70503d30fc..02777802acb 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_0.snap @@ -30,7 +30,7 @@ expression: artifact "type": { "kind": "integer", "sign": "unsigned", - "width": 8 + "width": 128 }, "visibility": "private" } @@ -61,12 +61,12 @@ expression: artifact }, "bytecode": [ "func 0", - "current witness index : _114", + "current witness index : _84", "private parameters indices : [_0, _1, _2]", "public parameters indices : []", "return value indices : []", "BLACKBOX::RANGE [(_1, 128)] []", - "BLACKBOX::RANGE [(_2, 8)] []", + "BLACKBOX::RANGE [(_2, 128)] []", "EXPR [ (1, _0) (1, _1) -2358023 ]", "EXPR [ (-1, _0) (1, _1) -2333333 ]", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_6, _7]", @@ -122,12 +122,13 @@ expression: artifact "EXPR [ (-1, _1) (-1, _29) 340282366920938463463374607431768211455 ]", "BLACKBOX::AND [(_28, 128), (_29, 128)] [_30]", "EXPR [ (-1, _30) 340282366920938463463374607431765853440 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 128 ], EXPR [ 256 ]], outputs: [_31, _32]", - "BLACKBOX::RANGE [(_31, 1)] []", - "BLACKBOX::RANGE [(_32, 8)] []", - "EXPR [ (1, _2) (-256, _31) (-1, _32) 128 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _31, _2) (1, _2) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_33, _34, _35, _36, _37, _38, _39, _40]]", - "BLACKBOX::RANGE [(_33, 1)] []", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 340282366920938463463374607431768211328 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_31, _32]", + "BLACKBOX::RANGE [(_32, 129)] []", + "EXPR [ (-1, _32) (-1, _33) 340282366920938463463374607431768211455 ]", + "BLACKBOX::RANGE [(_33, 129)] []", + "EXPR [ (1, _2) (-340282366920938463463374607431768211456, _31) (-1, _32) 340282366920938463463374607431768211328 ]", + "EXPR [ (-1, _31) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_34, _35, _36, _37, _38, _39, _40, _41]]", "BLACKBOX::RANGE [(_34, 1)] []", "BLACKBOX::RANGE [(_35, 1)] []", "BLACKBOX::RANGE [(_36, 1)] []", @@ -135,107 +136,73 @@ expression: artifact "BLACKBOX::RANGE [(_38, 1)] []", "BLACKBOX::RANGE [(_39, 1)] []", "BLACKBOX::RANGE [(_40, 1)] []", - "EXPR [ (-1, _2, _31) (1, _2) (-1, _33) (-2, _34) (-4, _35) (-8, _36) (-16, _37) (-32, _38) (-64, _39) (-128, _40) 0 ]", - "EXPR [ (1, _40, _40) (2, _40) (-1, _41) 1 ]", - "EXPR [ (-1, _39) (-1, _42) 1 ]", - "EXPR [ (2, _39, _41) (1, _41, _42) (-1, _43) 0 ]", - "EXPR [ (1, _43, _43) (-1, _44) 0 ]", - "EXPR [ (-1, _38) (-1, _45) 1 ]", - "EXPR [ (2, _38, _44) (1, _44, _45) (-1, _46) 0 ]", - "EXPR [ (1, _46, _46) (-1, _47) 0 ]", - "EXPR [ (-1, _37) (-1, _48) 1 ]", - "EXPR [ (2, _37, _47) (1, _47, _48) (-1, _49) 0 ]", - "EXPR [ (1, _49, _49) (-1, _50) 0 ]", - "EXPR [ (-1, _36) (-1, _51) 1 ]", - "EXPR [ (2, _36, _50) (1, _50, _51) (-1, _52) 0 ]", - "EXPR [ (1, _52, _52) (-1, _53) 0 ]", - "EXPR [ (-1, _35) (-1, _54) 1 ]", - "EXPR [ (2, _35, _53) (1, _53, _54) (-1, _55) 0 ]", - "EXPR [ (1, _55, _55) (-1, _56) 0 ]", - "EXPR [ (-1, _34) (-1, _57) 1 ]", - "EXPR [ (2, _34, _56) (1, _56, _57) (-1, _58) 0 ]", - "EXPR [ (1, _58, _58) (-1, _59) 0 ]", - "EXPR [ (-1, _33) (-1, _60) 1 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (2, _59, _33) (1, _59, _60) 0 ]], outputs: [_61]", - "EXPR [ (2, _33, _59) (1, _59, _60) (-1, _62) 0 ]", - "EXPR [ (1, _61, _62) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _62) 0 ]], outputs: [_63, _64]", - "BLACKBOX::RANGE [(_63, 128)] []", - "BLACKBOX::RANGE [(_64, 128)] []", - "EXPR [ (1, _62) (-1, _64) (-1, _65) -1 ]", + "BLACKBOX::RANGE [(_41, 1)] []", + "EXPR [ (1, _2) (-1, _34) (-2, _35) (-4, _36) (-8, _37) (-16, _38) (-32, _39) (-64, _40) (-128, _41) 0 ]", + "EXPR [ (1, _41, _41) (2, _41) (-1, _42) 1 ]", + "EXPR [ (-1, _40) (-1, _43) 1 ]", + "EXPR [ (2, _40, _42) (1, _42, _43) (-1, _44) 0 ]", + "EXPR [ (1, _44, _44) (-1, _45) 0 ]", + "EXPR [ (-1, _39) (-1, _46) 1 ]", + "EXPR [ (2, _39, _45) (1, _45, _46) (-1, _47) 0 ]", + "EXPR [ (1, _47, _47) (-1, _48) 0 ]", + "EXPR [ (-1, _38) (-1, _49) 1 ]", + "EXPR [ (2, _38, _48) (1, _48, _49) (-1, _50) 0 ]", + "EXPR [ (1, _50, _50) (-1, _51) 0 ]", + "EXPR [ (-1, _37) (-1, _52) 1 ]", + "EXPR [ (2, _37, _51) (1, _51, _52) (-1, _53) 0 ]", + "EXPR [ (1, _53, _53) (-1, _54) 0 ]", + "EXPR [ (-1, _36) (-1, _55) 1 ]", + "EXPR [ (2, _36, _54) (1, _54, _55) (-1, _56) 0 ]", + "EXPR [ (1, _56, _56) (-1, _57) 0 ]", + "EXPR [ (-1, _35) (-1, _58) 1 ]", + "EXPR [ (2, _35, _57) (1, _57, _58) (-1, _59) 0 ]", + "EXPR [ (1, _59, _59) (-1, _60) 0 ]", + "EXPR [ (-1, _34) (-1, _61) 1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (2, _60, _34) (1, _60, _61) 0 ]], outputs: [_62]", + "EXPR [ (2, _34, _60) (1, _60, _61) (-1, _63) 0 ]", + "EXPR [ (1, _62, _63) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _63) 0 ]], outputs: [_64, _65]", "BLACKBOX::RANGE [(_65, 128)] []", - "EXPR [ (-1, _62, _63) (1, _0) (-1, _64) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _63) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_66, _67]", - "BLACKBOX::RANGE [(_66, 64)] []", + "EXPR [ (1, _63) (-1, _65) (-1, _66) -1 ]", + "BLACKBOX::RANGE [(_66, 128)] []", + "EXPR [ (-1, _63, _64) (1, _0) (-1, _65) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _64) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_67, _68]", "BLACKBOX::RANGE [(_67, 64)] []", - "EXPR [ (1, _63) (-18446744073709551616, _66) (-1, _67) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _62) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_68, _69]", "BLACKBOX::RANGE [(_68, 64)] []", + "EXPR [ (1, _64) (-18446744073709551616, _67) (-1, _68) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _63) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_69, _70]", "BLACKBOX::RANGE [(_69, 64)] []", - "EXPR [ (1, _62) (-18446744073709551616, _68) (-1, _69) 0 ]", - "EXPR [ (1, _66, _68) 0 ]", - "EXPR [ (-1, _31, _63) (1, _63) -3086 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_70, _71, _72, _73, _74, _75, _76, _77]]", - "BLACKBOX::RANGE [(_70, 1)] []", - "BLACKBOX::RANGE [(_71, 1)] []", - "BLACKBOX::RANGE [(_72, 1)] []", - "BLACKBOX::RANGE [(_73, 1)] []", - "BLACKBOX::RANGE [(_74, 1)] []", - "BLACKBOX::RANGE [(_75, 1)] []", - "BLACKBOX::RANGE [(_76, 1)] []", - "BLACKBOX::RANGE [(_77, 1)] []", - "EXPR [ (1, _2) (-1, _70) (-2, _71) (-4, _72) (-8, _73) (-16, _74) (-32, _75) (-64, _76) (-128, _77) 0 ]", - "EXPR [ (1, _77, _77) (2, _77) (-1, _78) 1 ]", - "EXPR [ (-1, _76) (-1, _79) 1 ]", - "EXPR [ (2, _76, _78) (1, _78, _79) (-1, _80) 0 ]", - "EXPR [ (1, _80, _80) (-1, _81) 0 ]", - "EXPR [ (-1, _75) (-1, _82) 1 ]", - "EXPR [ (2, _75, _81) (1, _81, _82) (-1, _83) 0 ]", - "EXPR [ (1, _83, _83) (-1, _84) 0 ]", - "EXPR [ (-1, _74) (-1, _85) 1 ]", - "EXPR [ (2, _74, _84) (1, _84, _85) (-1, _86) 0 ]", - "EXPR [ (1, _86, _86) (-1, _87) 0 ]", - "EXPR [ (-1, _73) (-1, _88) 1 ]", - "EXPR [ (2, _73, _87) (1, _87, _88) (-1, _89) 0 ]", - "EXPR [ (1, _89, _89) (-1, _90) 0 ]", - "EXPR [ (-1, _72) (-1, _91) 1 ]", - "EXPR [ (2, _72, _90) (1, _90, _91) (-1, _92) 0 ]", - "EXPR [ (1, _92, _92) (-1, _93) 0 ]", - "EXPR [ (-1, _71) (-1, _94) 1 ]", - "EXPR [ (2, _71, _93) (1, _93, _94) (-1, _95) 0 ]", - "EXPR [ (1, _95, _95) (-1, _96) 0 ]", - "EXPR [ (-1, _70) (-1, _97) 1 ]", - "EXPR [ (-1, _31) (-1, _98) 1 ]", - "EXPR [ (2, _70, _96) (1, _96, _97) (-1, _99) 0 ]", - "EXPR [ (1, _98, _99) (-1, _100) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0, _100) 0 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_101, _102]", - "BLACKBOX::RANGE [(_101, 126)] []", - "EXPR [ (-1, _102) (-1, _103) 340282366920938463463374607431768211455 ]", - "BLACKBOX::RANGE [(_103, 129)] []", - "EXPR [ (1, _0, _100) (-340282366920938463463374607431768211456, _101) (-1, _102) 0 ]", - "EXPR [ (1, _101) (-1, _104) 20746827117051438823981594372716013474 ]", - "BLACKBOX::RANGE [(_104, 126)] []", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _101) 64323764613183177041862057485226039389 ]], outputs: [_105]", - "EXPR [ (-1, _101, _105) (64323764613183177041862057485226039389, _105) (1, _106) -1 ]", - "EXPR [ (-1, _101, _106) (64323764613183177041862057485226039389, _106) 0 ]", - "EXPR [ (-1, _102, _106) (53438638232309528389504892708671455233, _106) (-1, _107) 0 ]", - "BLACKBOX::RANGE [(_107, 129)] []", - "EXPR [ (1, _98) -1 ]", - "EXPR [ (1, _102) -49380 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) (-1, _1) 340282366920938463463374607431768211456 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_108, _109]", - "BLACKBOX::RANGE [(_109, 129)] []", - "EXPR [ (-1, _109) (-1, _110) 340282366920938463463374607431768211455 ]", - "BLACKBOX::RANGE [(_110, 129)] []", - "EXPR [ (1, _0) (-1, _1) (-340282366920938463463374607431768211456, _108) (-1, _109) 340282366920938463463374607431768211456 ]", - "EXPR [ (-1, _108) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _0) (1, _1) 340282366920938463463374607431768211456 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_111, _112]", - "BLACKBOX::RANGE [(_112, 129)] []", - "EXPR [ (-1, _112) (-1, _113) 340282366920938463463374607431768211455 ]", - "BLACKBOX::RANGE [(_113, 129)] []", - "EXPR [ (-1, _0) (1, _1) (-340282366920938463463374607431768211456, _111) (-1, _112) 340282366920938463463374607431768211456 ]", - "EXPR [ (-1, _111) 1 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) (-1, _1) 0 ]], outputs: [_114]", - "EXPR [ (1, _0, _114) (-1, _1, _114) -1 ]", + "BLACKBOX::RANGE [(_70, 64)] []", + "EXPR [ (1, _63) (-18446744073709551616, _69) (-1, _70) 0 ]", + "EXPR [ (1, _67, _69) 0 ]", + "EXPR [ (1, _64) -3086 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0, _63) 0 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_71, _72]", + "BLACKBOX::RANGE [(_71, 126)] []", + "EXPR [ (-1, _72) (-1, _73) 340282366920938463463374607431768211455 ]", + "BLACKBOX::RANGE [(_73, 129)] []", + "EXPR [ (1, _0, _63) (-340282366920938463463374607431768211456, _71) (-1, _72) 0 ]", + "EXPR [ (1, _71) (-1, _74) 20746827117051438823981594372716013474 ]", + "BLACKBOX::RANGE [(_74, 126)] []", + "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _71) 64323764613183177041862057485226039389 ]], outputs: [_75]", + "EXPR [ (-1, _71, _75) (64323764613183177041862057485226039389, _75) (1, _76) -1 ]", + "EXPR [ (-1, _71, _76) (64323764613183177041862057485226039389, _76) 0 ]", + "EXPR [ (-1, _72, _76) (53438638232309528389504892708671455233, _76) (-1, _77) 0 ]", + "BLACKBOX::RANGE [(_77, 129)] []", + "EXPR [ (1, _72) -49380 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) (-1, _1) 340282366920938463463374607431768211456 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_78, _79]", + "BLACKBOX::RANGE [(_79, 129)] []", + "EXPR [ (-1, _79) (-1, _80) 340282366920938463463374607431768211455 ]", + "BLACKBOX::RANGE [(_80, 129)] []", + "EXPR [ (1, _0) (-1, _1) (-340282366920938463463374607431768211456, _78) (-1, _79) 340282366920938463463374607431768211456 ]", + "EXPR [ (-1, _78) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _0) (1, _1) 340282366920938463463374607431768211456 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_81, _82]", + "BLACKBOX::RANGE [(_82, 129)] []", + "EXPR [ (-1, _82) (-1, _83) 340282366920938463463374607431768211455 ]", + "BLACKBOX::RANGE [(_83, 129)] []", + "EXPR [ (-1, _0) (1, _1) (-340282366920938463463374607431768211456, _81) (-1, _82) 340282366920938463463374607431768211456 ]", + "EXPR [ (-1, _81) 1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) (-1, _1) 0 ]], outputs: [_84]", + "EXPR [ (1, _0, _84) (-1, _1, _84) -1 ]", "unconstrained func 0", "[Const { destination: Direct(10), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(11), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(10), offset_address: Direct(11) }, BinaryFieldOp { destination: Direct(2), op: IntegerDiv, lhs: Direct(0), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Mul, lhs: Direct(2), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Sub, lhs: Direct(0), rhs: Direct(1) }, Mov { destination: Direct(0), source: Direct(2) }, Stop { return_data: HeapVector { pointer: Direct(11), size: Direct(10) } }]", "unconstrained func 1", @@ -243,10 +210,10 @@ expression: artifact "unconstrained func 2", "[Const { destination: Direct(5), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(6), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(7), bit_size: Integer(U32), value: 3 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(7), offset_address: Direct(5) }, Cast { destination: Direct(1), source: Direct(1), bit_size: Integer(U32) }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(7), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(3), op: IntegerDiv, lhs: Direct(0), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Mul, lhs: Direct(3), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Sub, lhs: Direct(0), rhs: Direct(4) }, Store { destination_pointer: Direct(9), source: Direct(4) }, BinaryIntOp { destination: Direct(9), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(6) }, Mov { destination: Direct(0), source: Direct(3) }, BinaryIntOp { destination: Direct(8), op: LessThan, bit_size: U32, lhs: Direct(9), rhs: Direct(7) }, JumpIf { condition: Direct(8), location: 7 }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, Stop { return_data: HeapVector { pointer: Direct(9), size: Direct(1) } }]" ], - "debug_symbols": "pdfLTuNAEAXQf/E6C3dV9YtfGY2QCQZFspLIJEgjxL9PtasuA4vZtDe+N486dBw/yMfwPD/dXx9P55fL2/Dw62N4Wk/Lcnp9XC7H6Xa6nPXZj8/DgIePt3We9anh2+s6dZ3W+XwbHs73ZTkM79Ny3970dp3OW96mVV8dD8N8ftZU8OW0zK19Hv5Nj/8fDcQ+HKh8jceeeck980kwn+q++dKzfhqjz1MY981Tz/pJEuZj2Defu9ZfMuYr7Zrn0LN+poJ56Vk/x6+/n2jffOlaf8X6ZeR989SzfuGKeZF986ln/VJw8ZGSds3HsWc+fl1/Ytf5921euuYTzr+Yw7752nP8pxHHbwq8b5675iO+v5R/fn+/9dF0PK0/7ngD6SXjMLB+8YdB9I2HIW7btG3zti3btm7bMFoEC7LQed1tQQFdfYgWySJbFIu6BY0WwYIs2MIUMoVMIVPIFDKFVdGzlVXRk4bJgi3EIloki2xRLOoWMlqYIqaIKWKKmCKmiCpB97IoE4Jmbbdd3XEKBT16Y2g3X02lQtuh3G6LmuIZPZUL+jFi8/RzxOJZLdPoGTzJkz3FM3omT/eSe8m97F52L7uX3cvuZfeye9m97F52r7hX3CvuFfeKe8W94l5xr7hX3KvuVfeqe9W96l51r7pX3avuVffCOKIEFEJhFEGJKAkloxSUJtd29I/tP41WAgqhMIqgRJSEklEKSvVCkAkyQSbIBJkgE2SCTJAJMkNmyAyZITNkhsyQGTJDZsgCWSALZIEskAWyQBbIAlkgR8gRcoQcIUfIEXI7sSi00mRqpaBUL+3kshJQmsytNFlaEZSIklAySpPbJbCdZdQugu00o3bpfZ/W0/S0zP7L4uV+Pn77oXH7c8Ur+ClyXS/H+fm+zu0Svb2mF+2/", + "debug_symbols": "pZbNbqswEIXfhTULezz+66tcXVUkIRUSIhFNKl1Fffc7w8y06aIbs+E7CTlfXcA2j+40Hu5vr9Nyvrx3L38e3WGd5nl6e50vx+E2XRb69vHZd/bx9baOI33VPZ2n1nVYx+XWvSz3ee67j2G+bz96vw7Lxtuw0lnXd+NyIpLwPM0jp8/+u+1+r3qIWvbhux5b+lhb+ilZP/t9/doyfnBZ++BhXz+0jB+wWD+Gff3cNP5SrV9xVz/4lvGHYA9vwJbxh/j19xPu65eW8aOz8aOL+/rQMn5Eb31M+/qpafwFrF/Krn50Lf34tf7Epvn31I9N/WTzL+awr19bnv/k7PlNPu7rh6Z+tPuX8s/795c+Dcdp/bHjdUBLRt8FuvF9h/TDvovbMW3HvB3Ldqzb0TuBF4CA+rTsexLQ6uujIAmyoAjqBnACLwBBEIgFxAJiAbGAWEAsgSx0twJZ6KIFEAQBCqIgCbKgCOoGdAKxoFhQLCgWFAuKBcni6RYgaTzNVqy87dKFc7xpEz1vvkRSeb6ggbdFIiqjMvEmS2Qf/R+xKKswOaVXgjIoURmVSam+pL6kvqy+rL6svqy+rL6svqy+rL6svqy+or6ivqK+or6ivqK+or6ivqK+or6qvqq+qr6qvqq+qr6qvqq+qr6qPu+cBW8BLAQLaCFaSBayhWLBzDwLfOXg+ZWDA1gIFtBCtJAsZAvFQtXAM0OCmcHMPD/Ac2AzcIgWkoVsoVhgc+A5ymbk4C2AhWABLbB5m9ls5rnNcwd4R/sY1mk4zKO+MJ/vy/Hp/fn272pn7A37ul6O4+m+jrzybOdoLfoP", "file_map": { "50": { - "source": "fn main(x: u128, y: u128, z: u8) {\n let const_x = 12345;\n let const_y = 2345678;\n let const_z = 2;\n\n assert_eq(x + y, const_x + const_y);\n assert_eq(y - x, const_y - const_x);\n assert_eq(x * y, const_x * const_y);\n assert_eq(y / x, const_y / const_x);\n assert_eq(y % x, const_y % const_x);\n assert_eq(!x, !const_x);\n assert_eq(x ^ y, const_x ^ const_y);\n assert_eq(x & y, const_x & const_y);\n assert_eq(x | y, const_x | const_y);\n assert_eq(x >> z, const_x >> const_z);\n assert_eq(x << z, const_x << const_z);\n assert_eq(x < y, const_x < const_y);\n assert_eq(x <= y, const_x <= const_y);\n assert_eq(x != y, const_x != const_y);\n assert_eq(y > x, const_y > const_x);\n assert_eq(y >= x, const_y >= const_x);\n}\n", + "source": "fn main(x: u128, y: u128, z: u128) {\n let const_x = 12345;\n let const_y = 2345678;\n let const_z = 2;\n\n assert_eq(x + y, const_x + const_y);\n assert_eq(y - x, const_y - const_x);\n assert_eq(x * y, const_x * const_y);\n assert_eq(y / x, const_y / const_x);\n assert_eq(y % x, const_y % const_x);\n assert_eq(!x, !const_x);\n assert_eq(x ^ y, const_x ^ const_y);\n assert_eq(x & y, const_x & const_y);\n assert_eq(x | y, const_x | const_y);\n assert_eq(x >> z, const_x >> const_z);\n assert_eq(x << z, const_x << const_z);\n assert_eq(x < y, const_x < const_y);\n assert_eq(x <= y, const_x <= const_y);\n assert_eq(x != y, const_x != const_y);\n assert_eq(y > x, const_y > const_x);\n assert_eq(y >= x, const_y >= const_x);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index e70503d30fc..02777802acb 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -30,7 +30,7 @@ expression: artifact "type": { "kind": "integer", "sign": "unsigned", - "width": 8 + "width": 128 }, "visibility": "private" } @@ -61,12 +61,12 @@ expression: artifact }, "bytecode": [ "func 0", - "current witness index : _114", + "current witness index : _84", "private parameters indices : [_0, _1, _2]", "public parameters indices : []", "return value indices : []", "BLACKBOX::RANGE [(_1, 128)] []", - "BLACKBOX::RANGE [(_2, 8)] []", + "BLACKBOX::RANGE [(_2, 128)] []", "EXPR [ (1, _0) (1, _1) -2358023 ]", "EXPR [ (-1, _0) (1, _1) -2333333 ]", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_6, _7]", @@ -122,12 +122,13 @@ expression: artifact "EXPR [ (-1, _1) (-1, _29) 340282366920938463463374607431768211455 ]", "BLACKBOX::AND [(_28, 128), (_29, 128)] [_30]", "EXPR [ (-1, _30) 340282366920938463463374607431765853440 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 128 ], EXPR [ 256 ]], outputs: [_31, _32]", - "BLACKBOX::RANGE [(_31, 1)] []", - "BLACKBOX::RANGE [(_32, 8)] []", - "EXPR [ (1, _2) (-256, _31) (-1, _32) 128 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (-1, _31, _2) (1, _2) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_33, _34, _35, _36, _37, _38, _39, _40]]", - "BLACKBOX::RANGE [(_33, 1)] []", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _2) 340282366920938463463374607431768211328 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_31, _32]", + "BLACKBOX::RANGE [(_32, 129)] []", + "EXPR [ (-1, _32) (-1, _33) 340282366920938463463374607431768211455 ]", + "BLACKBOX::RANGE [(_33, 129)] []", + "EXPR [ (1, _2) (-340282366920938463463374607431768211456, _31) (-1, _32) 340282366920938463463374607431768211328 ]", + "EXPR [ (-1, _31) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_34, _35, _36, _37, _38, _39, _40, _41]]", "BLACKBOX::RANGE [(_34, 1)] []", "BLACKBOX::RANGE [(_35, 1)] []", "BLACKBOX::RANGE [(_36, 1)] []", @@ -135,107 +136,73 @@ expression: artifact "BLACKBOX::RANGE [(_38, 1)] []", "BLACKBOX::RANGE [(_39, 1)] []", "BLACKBOX::RANGE [(_40, 1)] []", - "EXPR [ (-1, _2, _31) (1, _2) (-1, _33) (-2, _34) (-4, _35) (-8, _36) (-16, _37) (-32, _38) (-64, _39) (-128, _40) 0 ]", - "EXPR [ (1, _40, _40) (2, _40) (-1, _41) 1 ]", - "EXPR [ (-1, _39) (-1, _42) 1 ]", - "EXPR [ (2, _39, _41) (1, _41, _42) (-1, _43) 0 ]", - "EXPR [ (1, _43, _43) (-1, _44) 0 ]", - "EXPR [ (-1, _38) (-1, _45) 1 ]", - "EXPR [ (2, _38, _44) (1, _44, _45) (-1, _46) 0 ]", - "EXPR [ (1, _46, _46) (-1, _47) 0 ]", - "EXPR [ (-1, _37) (-1, _48) 1 ]", - "EXPR [ (2, _37, _47) (1, _47, _48) (-1, _49) 0 ]", - "EXPR [ (1, _49, _49) (-1, _50) 0 ]", - "EXPR [ (-1, _36) (-1, _51) 1 ]", - "EXPR [ (2, _36, _50) (1, _50, _51) (-1, _52) 0 ]", - "EXPR [ (1, _52, _52) (-1, _53) 0 ]", - "EXPR [ (-1, _35) (-1, _54) 1 ]", - "EXPR [ (2, _35, _53) (1, _53, _54) (-1, _55) 0 ]", - "EXPR [ (1, _55, _55) (-1, _56) 0 ]", - "EXPR [ (-1, _34) (-1, _57) 1 ]", - "EXPR [ (2, _34, _56) (1, _56, _57) (-1, _58) 0 ]", - "EXPR [ (1, _58, _58) (-1, _59) 0 ]", - "EXPR [ (-1, _33) (-1, _60) 1 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (2, _59, _33) (1, _59, _60) 0 ]], outputs: [_61]", - "EXPR [ (2, _33, _59) (1, _59, _60) (-1, _62) 0 ]", - "EXPR [ (1, _61, _62) -1 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _62) 0 ]], outputs: [_63, _64]", - "BLACKBOX::RANGE [(_63, 128)] []", - "BLACKBOX::RANGE [(_64, 128)] []", - "EXPR [ (1, _62) (-1, _64) (-1, _65) -1 ]", + "BLACKBOX::RANGE [(_41, 1)] []", + "EXPR [ (1, _2) (-1, _34) (-2, _35) (-4, _36) (-8, _37) (-16, _38) (-32, _39) (-64, _40) (-128, _41) 0 ]", + "EXPR [ (1, _41, _41) (2, _41) (-1, _42) 1 ]", + "EXPR [ (-1, _40) (-1, _43) 1 ]", + "EXPR [ (2, _40, _42) (1, _42, _43) (-1, _44) 0 ]", + "EXPR [ (1, _44, _44) (-1, _45) 0 ]", + "EXPR [ (-1, _39) (-1, _46) 1 ]", + "EXPR [ (2, _39, _45) (1, _45, _46) (-1, _47) 0 ]", + "EXPR [ (1, _47, _47) (-1, _48) 0 ]", + "EXPR [ (-1, _38) (-1, _49) 1 ]", + "EXPR [ (2, _38, _48) (1, _48, _49) (-1, _50) 0 ]", + "EXPR [ (1, _50, _50) (-1, _51) 0 ]", + "EXPR [ (-1, _37) (-1, _52) 1 ]", + "EXPR [ (2, _37, _51) (1, _51, _52) (-1, _53) 0 ]", + "EXPR [ (1, _53, _53) (-1, _54) 0 ]", + "EXPR [ (-1, _36) (-1, _55) 1 ]", + "EXPR [ (2, _36, _54) (1, _54, _55) (-1, _56) 0 ]", + "EXPR [ (1, _56, _56) (-1, _57) 0 ]", + "EXPR [ (-1, _35) (-1, _58) 1 ]", + "EXPR [ (2, _35, _57) (1, _57, _58) (-1, _59) 0 ]", + "EXPR [ (1, _59, _59) (-1, _60) 0 ]", + "EXPR [ (-1, _34) (-1, _61) 1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (2, _60, _34) (1, _60, _61) 0 ]], outputs: [_62]", + "EXPR [ (2, _34, _60) (1, _60, _61) (-1, _63) 0 ]", + "EXPR [ (1, _62, _63) -1 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _63) 0 ]], outputs: [_64, _65]", "BLACKBOX::RANGE [(_65, 128)] []", - "EXPR [ (-1, _62, _63) (1, _0) (-1, _64) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _63) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_66, _67]", - "BLACKBOX::RANGE [(_66, 64)] []", + "EXPR [ (1, _63) (-1, _65) (-1, _66) -1 ]", + "BLACKBOX::RANGE [(_66, 128)] []", + "EXPR [ (-1, _63, _64) (1, _0) (-1, _65) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _64) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_67, _68]", "BLACKBOX::RANGE [(_67, 64)] []", - "EXPR [ (1, _63) (-18446744073709551616, _66) (-1, _67) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _62) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_68, _69]", "BLACKBOX::RANGE [(_68, 64)] []", + "EXPR [ (1, _64) (-18446744073709551616, _67) (-1, _68) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _63) 0 ], EXPR [ 18446744073709551616 ]], outputs: [_69, _70]", "BLACKBOX::RANGE [(_69, 64)] []", - "EXPR [ (1, _62) (-18446744073709551616, _68) (-1, _69) 0 ]", - "EXPR [ (1, _66, _68) 0 ]", - "EXPR [ (-1, _31, _63) (1, _63) -3086 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_70, _71, _72, _73, _74, _75, _76, _77]]", - "BLACKBOX::RANGE [(_70, 1)] []", - "BLACKBOX::RANGE [(_71, 1)] []", - "BLACKBOX::RANGE [(_72, 1)] []", - "BLACKBOX::RANGE [(_73, 1)] []", - "BLACKBOX::RANGE [(_74, 1)] []", - "BLACKBOX::RANGE [(_75, 1)] []", - "BLACKBOX::RANGE [(_76, 1)] []", - "BLACKBOX::RANGE [(_77, 1)] []", - "EXPR [ (1, _2) (-1, _70) (-2, _71) (-4, _72) (-8, _73) (-16, _74) (-32, _75) (-64, _76) (-128, _77) 0 ]", - "EXPR [ (1, _77, _77) (2, _77) (-1, _78) 1 ]", - "EXPR [ (-1, _76) (-1, _79) 1 ]", - "EXPR [ (2, _76, _78) (1, _78, _79) (-1, _80) 0 ]", - "EXPR [ (1, _80, _80) (-1, _81) 0 ]", - "EXPR [ (-1, _75) (-1, _82) 1 ]", - "EXPR [ (2, _75, _81) (1, _81, _82) (-1, _83) 0 ]", - "EXPR [ (1, _83, _83) (-1, _84) 0 ]", - "EXPR [ (-1, _74) (-1, _85) 1 ]", - "EXPR [ (2, _74, _84) (1, _84, _85) (-1, _86) 0 ]", - "EXPR [ (1, _86, _86) (-1, _87) 0 ]", - "EXPR [ (-1, _73) (-1, _88) 1 ]", - "EXPR [ (2, _73, _87) (1, _87, _88) (-1, _89) 0 ]", - "EXPR [ (1, _89, _89) (-1, _90) 0 ]", - "EXPR [ (-1, _72) (-1, _91) 1 ]", - "EXPR [ (2, _72, _90) (1, _90, _91) (-1, _92) 0 ]", - "EXPR [ (1, _92, _92) (-1, _93) 0 ]", - "EXPR [ (-1, _71) (-1, _94) 1 ]", - "EXPR [ (2, _71, _93) (1, _93, _94) (-1, _95) 0 ]", - "EXPR [ (1, _95, _95) (-1, _96) 0 ]", - "EXPR [ (-1, _70) (-1, _97) 1 ]", - "EXPR [ (-1, _31) (-1, _98) 1 ]", - "EXPR [ (2, _70, _96) (1, _96, _97) (-1, _99) 0 ]", - "EXPR [ (1, _98, _99) (-1, _100) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0, _100) 0 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_101, _102]", - "BLACKBOX::RANGE [(_101, 126)] []", - "EXPR [ (-1, _102) (-1, _103) 340282366920938463463374607431768211455 ]", - "BLACKBOX::RANGE [(_103, 129)] []", - "EXPR [ (1, _0, _100) (-340282366920938463463374607431768211456, _101) (-1, _102) 0 ]", - "EXPR [ (1, _101) (-1, _104) 20746827117051438823981594372716013474 ]", - "BLACKBOX::RANGE [(_104, 126)] []", - "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _101) 64323764613183177041862057485226039389 ]], outputs: [_105]", - "EXPR [ (-1, _101, _105) (64323764613183177041862057485226039389, _105) (1, _106) -1 ]", - "EXPR [ (-1, _101, _106) (64323764613183177041862057485226039389, _106) 0 ]", - "EXPR [ (-1, _102, _106) (53438638232309528389504892708671455233, _106) (-1, _107) 0 ]", - "BLACKBOX::RANGE [(_107, 129)] []", - "EXPR [ (1, _98) -1 ]", - "EXPR [ (1, _102) -49380 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) (-1, _1) 340282366920938463463374607431768211456 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_108, _109]", - "BLACKBOX::RANGE [(_109, 129)] []", - "EXPR [ (-1, _109) (-1, _110) 340282366920938463463374607431768211455 ]", - "BLACKBOX::RANGE [(_110, 129)] []", - "EXPR [ (1, _0) (-1, _1) (-340282366920938463463374607431768211456, _108) (-1, _109) 340282366920938463463374607431768211456 ]", - "EXPR [ (-1, _108) 0 ]", - "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _0) (1, _1) 340282366920938463463374607431768211456 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_111, _112]", - "BLACKBOX::RANGE [(_112, 129)] []", - "EXPR [ (-1, _112) (-1, _113) 340282366920938463463374607431768211455 ]", - "BLACKBOX::RANGE [(_113, 129)] []", - "EXPR [ (-1, _0) (1, _1) (-340282366920938463463374607431768211456, _111) (-1, _112) 340282366920938463463374607431768211456 ]", - "EXPR [ (-1, _111) 1 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) (-1, _1) 0 ]], outputs: [_114]", - "EXPR [ (1, _0, _114) (-1, _1, _114) -1 ]", + "BLACKBOX::RANGE [(_70, 64)] []", + "EXPR [ (1, _63) (-18446744073709551616, _69) (-1, _70) 0 ]", + "EXPR [ (1, _67, _69) 0 ]", + "EXPR [ (1, _64) -3086 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0, _63) 0 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_71, _72]", + "BLACKBOX::RANGE [(_71, 126)] []", + "EXPR [ (-1, _72) (-1, _73) 340282366920938463463374607431768211455 ]", + "BLACKBOX::RANGE [(_73, 129)] []", + "EXPR [ (1, _0, _63) (-340282366920938463463374607431768211456, _71) (-1, _72) 0 ]", + "EXPR [ (1, _71) (-1, _74) 20746827117051438823981594372716013474 ]", + "BLACKBOX::RANGE [(_74, 126)] []", + "BRILLIG CALL func 1: inputs: [EXPR [ (-1, _71) 64323764613183177041862057485226039389 ]], outputs: [_75]", + "EXPR [ (-1, _71, _75) (64323764613183177041862057485226039389, _75) (1, _76) -1 ]", + "EXPR [ (-1, _71, _76) (64323764613183177041862057485226039389, _76) 0 ]", + "EXPR [ (-1, _72, _76) (53438638232309528389504892708671455233, _76) (-1, _77) 0 ]", + "BLACKBOX::RANGE [(_77, 129)] []", + "EXPR [ (1, _72) -49380 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) (-1, _1) 340282366920938463463374607431768211456 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_78, _79]", + "BLACKBOX::RANGE [(_79, 129)] []", + "EXPR [ (-1, _79) (-1, _80) 340282366920938463463374607431768211455 ]", + "BLACKBOX::RANGE [(_80, 129)] []", + "EXPR [ (1, _0) (-1, _1) (-340282366920938463463374607431768211456, _78) (-1, _79) 340282366920938463463374607431768211456 ]", + "EXPR [ (-1, _78) 0 ]", + "BRILLIG CALL func 0: inputs: [EXPR [ (-1, _0) (1, _1) 340282366920938463463374607431768211456 ], EXPR [ 340282366920938463463374607431768211456 ]], outputs: [_81, _82]", + "BLACKBOX::RANGE [(_82, 129)] []", + "EXPR [ (-1, _82) (-1, _83) 340282366920938463463374607431768211455 ]", + "BLACKBOX::RANGE [(_83, 129)] []", + "EXPR [ (-1, _0) (1, _1) (-340282366920938463463374607431768211456, _81) (-1, _82) 340282366920938463463374607431768211456 ]", + "EXPR [ (-1, _81) 1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) (-1, _1) 0 ]], outputs: [_84]", + "EXPR [ (1, _0, _84) (-1, _1, _84) -1 ]", "unconstrained func 0", "[Const { destination: Direct(10), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(11), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(10), offset_address: Direct(11) }, BinaryFieldOp { destination: Direct(2), op: IntegerDiv, lhs: Direct(0), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Mul, lhs: Direct(2), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Sub, lhs: Direct(0), rhs: Direct(1) }, Mov { destination: Direct(0), source: Direct(2) }, Stop { return_data: HeapVector { pointer: Direct(11), size: Direct(10) } }]", "unconstrained func 1", @@ -243,10 +210,10 @@ expression: artifact "unconstrained func 2", "[Const { destination: Direct(5), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(6), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(7), bit_size: Integer(U32), value: 3 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(7), offset_address: Direct(5) }, Cast { destination: Direct(1), source: Direct(1), bit_size: Integer(U32) }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Direct(7), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(3), op: IntegerDiv, lhs: Direct(0), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Mul, lhs: Direct(3), rhs: Direct(2) }, BinaryFieldOp { destination: Direct(4), op: Sub, lhs: Direct(0), rhs: Direct(4) }, Store { destination_pointer: Direct(9), source: Direct(4) }, BinaryIntOp { destination: Direct(9), op: Add, bit_size: U32, lhs: Direct(9), rhs: Direct(6) }, Mov { destination: Direct(0), source: Direct(3) }, BinaryIntOp { destination: Direct(8), op: LessThan, bit_size: U32, lhs: Direct(9), rhs: Direct(7) }, JumpIf { condition: Direct(8), location: 7 }, Const { destination: Direct(9), bit_size: Integer(U32), value: 10 }, Stop { return_data: HeapVector { pointer: Direct(9), size: Direct(1) } }]" ], - "debug_symbols": "pdfLTuNAEAXQf/E6C3dV9YtfGY2QCQZFspLIJEgjxL9PtasuA4vZtDe+N486dBw/yMfwPD/dXx9P55fL2/Dw62N4Wk/Lcnp9XC7H6Xa6nPXZj8/DgIePt3We9anh2+s6dZ3W+XwbHs73ZTkM79Ny3970dp3OW96mVV8dD8N8ftZU8OW0zK19Hv5Nj/8fDcQ+HKh8jceeeck980kwn+q++dKzfhqjz1MY981Tz/pJEuZj2Defu9ZfMuYr7Zrn0LN+poJ56Vk/x6+/n2jffOlaf8X6ZeR989SzfuGKeZF986ln/VJw8ZGSds3HsWc+fl1/Ytf5921euuYTzr+Yw7752nP8pxHHbwq8b5675iO+v5R/fn+/9dF0PK0/7ngD6SXjMLB+8YdB9I2HIW7btG3zti3btm7bMFoEC7LQed1tQQFdfYgWySJbFIu6BY0WwYIs2MIUMoVMIVPIFDKFVdGzlVXRk4bJgi3EIloki2xRLOoWMlqYIqaIKWKKmCKmiCpB97IoE4Jmbbdd3XEKBT16Y2g3X02lQtuh3G6LmuIZPZUL+jFi8/RzxOJZLdPoGTzJkz3FM3omT/eSe8m97F52L7uX3cvuZfeye9m97F52r7hX3CvuFfeKe8W94l5xr7hX3KvuVfeqe9W96l51r7pX3avuVffCOKIEFEJhFEGJKAkloxSUJtd29I/tP41WAgqhMIqgRJSEklEKSvVCkAkyQSbIBJkgE2SCTJAJMkNmyAyZITNkhsyQGTJDZsgCWSALZIEskAWyQBbIAlkgR8gRcoQcIUfIEXI7sSi00mRqpaBUL+3kshJQmsytNFlaEZSIklAySpPbJbCdZdQugu00o3bpfZ/W0/S0zP7L4uV+Pn77oXH7c8Ur+ClyXS/H+fm+zu0Svb2mF+2/", + "debug_symbols": "pZbNbqswEIXfhTULezz+66tcXVUkIRUSIhFNKl1Fffc7w8y06aIbs+E7CTlfXcA2j+40Hu5vr9Nyvrx3L38e3WGd5nl6e50vx+E2XRb69vHZd/bx9baOI33VPZ2n1nVYx+XWvSz3ee67j2G+bz96vw7Lxtuw0lnXd+NyIpLwPM0jp8/+u+1+r3qIWvbhux5b+lhb+ilZP/t9/doyfnBZ++BhXz+0jB+wWD+Gff3cNP5SrV9xVz/4lvGHYA9vwJbxh/j19xPu65eW8aOz8aOL+/rQMn5Eb31M+/qpafwFrF/Krn50Lf34tf7Epvn31I9N/WTzL+awr19bnv/k7PlNPu7rh6Z+tPuX8s/795c+Dcdp/bHjdUBLRt8FuvF9h/TDvovbMW3HvB3Ldqzb0TuBF4CA+rTsexLQ6uujIAmyoAjqBnACLwBBEIgFxAJiAbGAWEAsgSx0twJZ6KIFEAQBCqIgCbKgCOoGdAKxoFhQLCgWFAuKBcni6RYgaTzNVqy87dKFc7xpEz1vvkRSeb6ggbdFIiqjMvEmS2Qf/R+xKKswOaVXgjIoURmVSam+pL6kvqy+rL6svqy+rL6svqy+rL6svqy+or6ivqK+or6ivqK+or6ivqK+or6qvqq+qr6qvqq+qr6qvqq+qr6qPu+cBW8BLAQLaCFaSBayhWLBzDwLfOXg+ZWDA1gIFtBCtJAsZAvFQtXAM0OCmcHMPD/Ac2AzcIgWkoVsoVhgc+A5ymbk4C2AhWABLbB5m9ls5rnNcwd4R/sY1mk4zKO+MJ/vy/Hp/fn272pn7A37ul6O4+m+jrzybOdoLfoP", "file_map": { "50": { - "source": "fn main(x: u128, y: u128, z: u8) {\n let const_x = 12345;\n let const_y = 2345678;\n let const_z = 2;\n\n assert_eq(x + y, const_x + const_y);\n assert_eq(y - x, const_y - const_x);\n assert_eq(x * y, const_x * const_y);\n assert_eq(y / x, const_y / const_x);\n assert_eq(y % x, const_y % const_x);\n assert_eq(!x, !const_x);\n assert_eq(x ^ y, const_x ^ const_y);\n assert_eq(x & y, const_x & const_y);\n assert_eq(x | y, const_x | const_y);\n assert_eq(x >> z, const_x >> const_z);\n assert_eq(x << z, const_x << const_z);\n assert_eq(x < y, const_x < const_y);\n assert_eq(x <= y, const_x <= const_y);\n assert_eq(x != y, const_x != const_y);\n assert_eq(y > x, const_y > const_x);\n assert_eq(y >= x, const_y >= const_x);\n}\n", + "source": "fn main(x: u128, y: u128, z: u128) {\n let const_x = 12345;\n let const_y = 2345678;\n let const_z = 2;\n\n assert_eq(x + y, const_x + const_y);\n assert_eq(y - x, const_y - const_x);\n assert_eq(x * y, const_x * const_y);\n assert_eq(y / x, const_y / const_x);\n assert_eq(y % x, const_y % const_x);\n assert_eq(!x, !const_x);\n assert_eq(x ^ y, const_x ^ const_y);\n assert_eq(x & y, const_x & const_y);\n assert_eq(x | y, const_x | const_y);\n assert_eq(x >> z, const_x >> const_z);\n assert_eq(x << z, const_x << const_z);\n assert_eq(x < y, const_x < const_y);\n assert_eq(x <= y, const_x <= const_y);\n assert_eq(x != y, const_x != const_y);\n assert_eq(y > x, const_y > const_x);\n assert_eq(y >= x, const_y >= const_x);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 37bda41f683..e52c9d664b6 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -30,7 +30,7 @@ expression: artifact "type": { "kind": "integer", "sign": "unsigned", - "width": 8 + "width": 128 }, "visibility": "private" } @@ -67,12 +67,12 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ], EXPR [ (1, _2) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(4), offset_address: Relative(5) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U128) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U128) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Mov { destination: Relative(3), source: Direct(32838) }, Call { location: 17 }, Call { location: 18 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 121 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U128, lhs: Relative(1), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 23 }, Call { location: 127 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2358023 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 28 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 32 }, Call { location: 130 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2333333 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 37 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Mul, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U128, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 45 }, BinaryIntOp { destination: Relative(8), op: Div, bit_size: U128, lhs: Relative(4), rhs: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 45 }, Call { location: 133 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 28957394910 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 50 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 190 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 56 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U128, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U128, lhs: Relative(2), rhs: Relative(6) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 128 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 64 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Not { destination: Relative(4), source: Relative(1), bit_size: U128 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 340282366920938463463374607431768199110 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 70 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Xor, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2358007 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 76 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: And, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 8 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 82 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2358015 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 88 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U128, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 3086 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 94 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U128, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U8, lhs: Relative(3), rhs: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 100 }, Call { location: 136 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 49380 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 105 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 109 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 115 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(1), location: 120 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 126 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(4), offset_address: Relative(5) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U128) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U128) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U128) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Mov { destination: Relative(3), source: Direct(32838) }, Call { location: 17 }, Call { location: 18 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 120 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U128, lhs: Relative(1), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 23 }, Call { location: 126 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2358023 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 28 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 32 }, Call { location: 129 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2333333 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 37 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Mul, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U128, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 45 }, BinaryIntOp { destination: Relative(8), op: Div, bit_size: U128, lhs: Relative(4), rhs: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 45 }, Call { location: 132 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 28957394910 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 50 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 190 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 56 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U128, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U128, lhs: Relative(2), rhs: Relative(6) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 128 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 64 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Not { destination: Relative(4), source: Relative(1), bit_size: U128 }, Const { destination: Relative(6), bit_size: Integer(U128), value: 340282366920938463463374607431768199110 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 70 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: Xor, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 2358007 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 76 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: And, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 8 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 82 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 2358015 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 88 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U128, lhs: Relative(3), rhs: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(4), location: 92 }, Call { location: 135 }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U128, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 3086 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 98 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U128, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U128), value: 49380 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 104 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 108 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 114 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(1), location: 119 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 125 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZZNjuJADIXvUussyvVfXKXVQgFCK1IUUBpGGiHuPnZsM/SiN5VNvhfCe7FNKtTDnIbD/Ws/zufLt9l9PMxhGadp/NpPl2N/Gy8zfvowlg5QzQ464ywDGI7hzc4hAiMyEiMzitl5RF3hLQMYmBIQnhEYkZEYmBIRhVFXBMsAhmN4RmBgSkIkRmYURl0RMSUjMKUgHMMzAiMyMKUiMqMwaC62M8kKQeiEXhiEmAU4s5SEWViElZkpDweXKQ+HlJ3QC4MwCikPJ5UpDzvPRViZxQpBSHnYfqE87L8EYRQmYRZSHg6hUB72Xa0QhE7ohfQwYL81CpMwC4uwMsFioAMSoMKp8CqCCkp1JCjWk8gqigpKxokAUHIkASqcCq8iqKDkRIKSM4msoqig5Px8dkbXyf62DAMtk7eFg8vp2i/DfDO7+T5NnfnTT/f1S9/Xfl556xe8it0P8wmJgedxGkg9u/9u+7sVqNPVDK687LHFH3KLPwX1p7rNX1rqdzaK34Hd5nct9buQ1B9hmz831V+y+qvb5PfQUr93Rf2hpX4fX/dPbpu/NNVftf5g/Ta/a6k/+Kr+ELb5U0v9oejLJ5S0yR9tiz++3j+xaf29+UOTP+n6ixm2+WvL85+sPr8J/Da/b/JH/f1STNv8+af/E8/647j82Eo+KWkZ+8M0yOn5Ph/frt7+XvWKbkWvy+U4nO7LQElv+1E8fgBuBsClT/pPplNvO/Du80m3/wc=", + "debug_symbols": "pZbNjuowDIXfJesu4vyHVxkhVKCMKlUFdeBKV4h3v3ZtzzCLu0k3/U4J59QxCc3TnIfj4/Mwzpfrl9l9PM1xGadp/DxM11N/H68zfvo0li5QzQ464ywDGI7hzc4hAiMyEiMzitl5RF3hLQMYmBIQnhEYkZEYmBIRhVFXBMsAhmN4RmBgSkIkRmYURl0RMSUjMKUgHMMzAiMyMKUiMqMwqC+2M8kKQeiEXhiEmAXYs5SEWViElZkpDxuXKQ+blJ3QC4MwCikPO5UpD2eei7AyixWCkPJw+oXycP4lCKMwCbOQ8rAJpTKrFYLQCSkP+1KDMAqTMAsxz2E/KuY5nC9YqwJUOBVeBa0wR4LWmCeRVGQVFBxIUDLOFMCqABVOhVdByYkEJWcSSUVWQcn59eqMbo/DfRkG2h1v+wV30a1fhvludvNjmjrzp58e65e+bv288t4vOIqTH+YzEgMv4zSQenU/bvt/K1DNqxn8jz22+ENt8aek/gzb/LWlfmez+B24bX7fUr8LRf3Rb/PnpvpLVX8Nm/weWur3XhevDy31+/j9/BS2+UtL/cFq/cHGbX7XUn8IoP6QtvlTU/3Fqb+UTf5oW/zx+/8nNu2/N39s8ifdfzH7bf7asv6T1fWbIG7z+yZ/1N8vxbLNn3/793jXn8bl1wnyRUnL2B+nQW4vj/n0Nnr/e9MRPYHelutpOD+WgZLejqF4/QA8OOArbE/v5PW2duBh/6LH/wM=", "file_map": { "50": { - "source": "fn main(x: u128, y: u128, z: u8) {\n let const_x = 12345;\n let const_y = 2345678;\n let const_z = 2;\n\n assert_eq(x + y, const_x + const_y);\n assert_eq(y - x, const_y - const_x);\n assert_eq(x * y, const_x * const_y);\n assert_eq(y / x, const_y / const_x);\n assert_eq(y % x, const_y % const_x);\n assert_eq(!x, !const_x);\n assert_eq(x ^ y, const_x ^ const_y);\n assert_eq(x & y, const_x & const_y);\n assert_eq(x | y, const_x | const_y);\n assert_eq(x >> z, const_x >> const_z);\n assert_eq(x << z, const_x << const_z);\n assert_eq(x < y, const_x < const_y);\n assert_eq(x <= y, const_x <= const_y);\n assert_eq(x != y, const_x != const_y);\n assert_eq(y > x, const_y > const_x);\n assert_eq(y >= x, const_y >= const_x);\n}\n", + "source": "fn main(x: u128, y: u128, z: u128) {\n let const_x = 12345;\n let const_y = 2345678;\n let const_z = 2;\n\n assert_eq(x + y, const_x + const_y);\n assert_eq(y - x, const_y - const_x);\n assert_eq(x * y, const_x * const_y);\n assert_eq(y / x, const_y / const_x);\n assert_eq(y % x, const_y % const_x);\n assert_eq(!x, !const_x);\n assert_eq(x ^ y, const_x ^ const_y);\n assert_eq(x & y, const_x & const_y);\n assert_eq(x | y, const_x | const_y);\n assert_eq(x >> z, const_x >> const_z);\n assert_eq(x << z, const_x << const_z);\n assert_eq(x < y, const_x < const_y);\n assert_eq(x <= y, const_x <= const_y);\n assert_eq(x != y, const_x != const_y);\n assert_eq(y > x, const_y > const_x);\n assert_eq(y >= x, const_y >= const_x);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_true_inliner_0.snap index 37bda41f683..e52c9d664b6 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_true_inliner_0.snap @@ -30,7 +30,7 @@ expression: artifact "type": { "kind": "integer", "sign": "unsigned", - "width": 8 + "width": 128 }, "visibility": "private" } @@ -67,12 +67,12 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ], EXPR [ (1, _2) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(4), offset_address: Relative(5) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U128) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U128) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Mov { destination: Relative(3), source: Direct(32838) }, Call { location: 17 }, Call { location: 18 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 121 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U128, lhs: Relative(1), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 23 }, Call { location: 127 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2358023 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 28 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 32 }, Call { location: 130 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2333333 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 37 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Mul, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U128, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 45 }, BinaryIntOp { destination: Relative(8), op: Div, bit_size: U128, lhs: Relative(4), rhs: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 45 }, Call { location: 133 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 28957394910 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 50 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 190 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 56 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U128, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U128, lhs: Relative(2), rhs: Relative(6) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 128 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 64 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Not { destination: Relative(4), source: Relative(1), bit_size: U128 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 340282366920938463463374607431768199110 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 70 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Xor, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2358007 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 76 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: And, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 8 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 82 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2358015 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 88 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U128, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 3086 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 94 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U128, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U8, lhs: Relative(3), rhs: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 100 }, Call { location: 136 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 49380 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 105 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 109 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 115 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(1), location: 120 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 126 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(4), offset_address: Relative(5) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U128) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U128) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U128) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Mov { destination: Relative(3), source: Direct(32838) }, Call { location: 17 }, Call { location: 18 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 120 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U128, lhs: Relative(1), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 23 }, Call { location: 126 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2358023 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 28 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 32 }, Call { location: 129 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2333333 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 37 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Mul, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U128, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 45 }, BinaryIntOp { destination: Relative(8), op: Div, bit_size: U128, lhs: Relative(4), rhs: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 45 }, Call { location: 132 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 28957394910 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 50 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 190 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 56 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U128, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U128, lhs: Relative(2), rhs: Relative(6) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 128 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 64 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Not { destination: Relative(4), source: Relative(1), bit_size: U128 }, Const { destination: Relative(6), bit_size: Integer(U128), value: 340282366920938463463374607431768199110 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 70 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: Xor, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 2358007 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 76 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: And, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 8 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 82 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 2358015 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 88 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U128, lhs: Relative(3), rhs: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(4), location: 92 }, Call { location: 135 }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U128, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 3086 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 98 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U128, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U128), value: 49380 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 104 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 108 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 114 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(1), location: 119 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 125 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZZNjuJADIXvUussyvVfXKXVQgFCK1IUUBpGGiHuPnZsM/SiN5VNvhfCe7FNKtTDnIbD/Ws/zufLt9l9PMxhGadp/NpPl2N/Gy8zfvowlg5QzQ464ywDGI7hzc4hAiMyEiMzitl5RF3hLQMYmBIQnhEYkZEYmBIRhVFXBMsAhmN4RmBgSkIkRmYURl0RMSUjMKUgHMMzAiMyMKUiMqMwaC62M8kKQeiEXhiEmAU4s5SEWViElZkpDweXKQ+HlJ3QC4MwCikPJ5UpDzvPRViZxQpBSHnYfqE87L8EYRQmYRZSHg6hUB72Xa0QhE7ohfQwYL81CpMwC4uwMsFioAMSoMKp8CqCCkp1JCjWk8gqigpKxokAUHIkASqcCq8iqKDkRIKSM4msoqig5Px8dkbXyf62DAMtk7eFg8vp2i/DfDO7+T5NnfnTT/f1S9/Xfl556xe8it0P8wmJgedxGkg9u/9u+7sVqNPVDK687LHFH3KLPwX1p7rNX1rqdzaK34Hd5nct9buQ1B9hmz831V+y+qvb5PfQUr93Rf2hpX4fX/dPbpu/NNVftf5g/Ta/a6k/+Kr+ELb5U0v9oejLJ5S0yR9tiz++3j+xaf29+UOTP+n6ixm2+WvL85+sPr8J/Da/b/JH/f1STNv8+af/E8/647j82Eo+KWkZ+8M0yOn5Ph/frt7+XvWKbkWvy+U4nO7LQElv+1E8fgBuBsClT/pPplNvO/Du80m3/wc=", + "debug_symbols": "pZbNjuowDIXfJesu4vyHVxkhVKCMKlUFdeBKV4h3v3ZtzzCLu0k3/U4J59QxCc3TnIfj4/Mwzpfrl9l9PM1xGadp/DxM11N/H68zfvo0li5QzQ464ywDGI7hzc4hAiMyEiMzitl5RF3hLQMYmBIQnhEYkZEYmBIRhVFXBMsAhmN4RmBgSkIkRmYURl0RMSUjMKUgHMMzAiMyMKUiMqMwqC+2M8kKQeiEXhiEmAXYs5SEWViElZkpDxuXKQ+blJ3QC4MwCikPO5UpD2eei7AyixWCkPJw+oXycP4lCKMwCbOQ8rAJpTKrFYLQCSkP+1KDMAqTMAsxz2E/KuY5nC9YqwJUOBVeBa0wR4LWmCeRVGQVFBxIUDLOFMCqABVOhVdByYkEJWcSSUVWQcn59eqMbo/DfRkG2h1v+wV30a1fhvludvNjmjrzp58e65e+bv288t4vOIqTH+YzEgMv4zSQenU/bvt/K1DNqxn8jz22+ENt8aek/gzb/LWlfmez+B24bX7fUr8LRf3Rb/PnpvpLVX8Nm/weWur3XhevDy31+/j9/BS2+UtL/cFq/cHGbX7XUn8IoP6QtvlTU/3Fqb+UTf5oW/zx+/8nNu2/N39s8ifdfzH7bf7asv6T1fWbIG7z+yZ/1N8vxbLNn3/793jXn8bl1wnyRUnL2B+nQW4vj/n0Nnr/e9MRPYHelutpOD+WgZLejqF4/QA8OOArbE/v5PW2duBh/6LH/wM=", "file_map": { "50": { - "source": "fn main(x: u128, y: u128, z: u8) {\n let const_x = 12345;\n let const_y = 2345678;\n let const_z = 2;\n\n assert_eq(x + y, const_x + const_y);\n assert_eq(y - x, const_y - const_x);\n assert_eq(x * y, const_x * const_y);\n assert_eq(y / x, const_y / const_x);\n assert_eq(y % x, const_y % const_x);\n assert_eq(!x, !const_x);\n assert_eq(x ^ y, const_x ^ const_y);\n assert_eq(x & y, const_x & const_y);\n assert_eq(x | y, const_x | const_y);\n assert_eq(x >> z, const_x >> const_z);\n assert_eq(x << z, const_x << const_z);\n assert_eq(x < y, const_x < const_y);\n assert_eq(x <= y, const_x <= const_y);\n assert_eq(x != y, const_x != const_y);\n assert_eq(y > x, const_y > const_x);\n assert_eq(y >= x, const_y >= const_x);\n}\n", + "source": "fn main(x: u128, y: u128, z: u128) {\n let const_x = 12345;\n let const_y = 2345678;\n let const_z = 2;\n\n assert_eq(x + y, const_x + const_y);\n assert_eq(y - x, const_y - const_x);\n assert_eq(x * y, const_x * const_y);\n assert_eq(y / x, const_y / const_x);\n assert_eq(y % x, const_y % const_x);\n assert_eq(!x, !const_x);\n assert_eq(x ^ y, const_x ^ const_y);\n assert_eq(x & y, const_x & const_y);\n assert_eq(x | y, const_x | const_y);\n assert_eq(x >> z, const_x >> const_z);\n assert_eq(x << z, const_x << const_z);\n assert_eq(x < y, const_x < const_y);\n assert_eq(x <= y, const_x <= const_y);\n assert_eq(x != y, const_x != const_y);\n assert_eq(y > x, const_y > const_x);\n assert_eq(y >= x, const_y >= const_x);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 37bda41f683..e52c9d664b6 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -30,7 +30,7 @@ expression: artifact "type": { "kind": "integer", "sign": "unsigned", - "width": 8 + "width": 128 }, "visibility": "private" } @@ -67,12 +67,12 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ], EXPR [ (1, _1) 0 ], EXPR [ (1, _2) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(4), offset_address: Relative(5) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U128) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U128) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Mov { destination: Relative(3), source: Direct(32838) }, Call { location: 17 }, Call { location: 18 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 121 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U128, lhs: Relative(1), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 23 }, Call { location: 127 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2358023 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 28 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 32 }, Call { location: 130 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2333333 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 37 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Mul, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U128, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 45 }, BinaryIntOp { destination: Relative(8), op: Div, bit_size: U128, lhs: Relative(4), rhs: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 45 }, Call { location: 133 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 28957394910 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 50 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 190 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 56 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U128, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U128, lhs: Relative(2), rhs: Relative(6) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 128 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 64 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Not { destination: Relative(4), source: Relative(1), bit_size: U128 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 340282366920938463463374607431768199110 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 70 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Xor, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2358007 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 76 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: And, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 8 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 82 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2358015 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 88 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U128, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 3086 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 94 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U128, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 128 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U8, lhs: Relative(3), rhs: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 100 }, Call { location: 136 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 49380 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 105 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 109 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 115 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(1), location: 120 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 126 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(4), offset_address: Relative(5) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U128) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U128) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U128) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Mov { destination: Relative(3), source: Direct(32838) }, Call { location: 17 }, Call { location: 18 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 120 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U128, lhs: Relative(1), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 23 }, Call { location: 126 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2358023 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 28 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 32 }, Call { location: 129 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 2333333 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 37 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Mul, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U128, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 45 }, BinaryIntOp { destination: Relative(8), op: Div, bit_size: U128, lhs: Relative(4), rhs: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 45 }, Call { location: 132 }, Const { destination: Relative(5), bit_size: Integer(U128), value: 28957394910 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 50 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Div, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 190 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 56 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(5), op: Div, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U128, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U128, lhs: Relative(2), rhs: Relative(6) }, Const { destination: Relative(5), bit_size: Integer(U128), value: 128 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 64 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Not { destination: Relative(4), source: Relative(1), bit_size: U128 }, Const { destination: Relative(6), bit_size: Integer(U128), value: 340282366920938463463374607431768199110 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 70 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: Xor, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 2358007 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 76 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: And, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 8 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 82 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 2358015 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 88 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U128, lhs: Relative(3), rhs: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(4), location: 92 }, Call { location: 135 }, BinaryIntOp { destination: Relative(4), op: Shr, bit_size: U128, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(6), bit_size: Integer(U128), value: 3086 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(7), location: 98 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(4), op: Shl, bit_size: U128, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U128), value: 49380 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U128, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 104 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 108 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U128, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 114 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U128, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(1), location: 119 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 125 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 7233212735005103307 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZZNjuJADIXvUussyvVfXKXVQgFCK1IUUBpGGiHuPnZsM/SiN5VNvhfCe7FNKtTDnIbD/Ws/zufLt9l9PMxhGadp/NpPl2N/Gy8zfvowlg5QzQ464ywDGI7hzc4hAiMyEiMzitl5RF3hLQMYmBIQnhEYkZEYmBIRhVFXBMsAhmN4RmBgSkIkRmYURl0RMSUjMKUgHMMzAiMyMKUiMqMwaC62M8kKQeiEXhiEmAU4s5SEWViElZkpDweXKQ+HlJ3QC4MwCikPJ5UpDzvPRViZxQpBSHnYfqE87L8EYRQmYRZSHg6hUB72Xa0QhE7ohfQwYL81CpMwC4uwMsFioAMSoMKp8CqCCkp1JCjWk8gqigpKxokAUHIkASqcCq8iqKDkRIKSM4msoqig5Px8dkbXyf62DAMtk7eFg8vp2i/DfDO7+T5NnfnTT/f1S9/Xfl556xe8it0P8wmJgedxGkg9u/9u+7sVqNPVDK687LHFH3KLPwX1p7rNX1rqdzaK34Hd5nct9buQ1B9hmz831V+y+qvb5PfQUr93Rf2hpX4fX/dPbpu/NNVftf5g/Ta/a6k/+Kr+ELb5U0v9oejLJ5S0yR9tiz++3j+xaf29+UOTP+n6ixm2+WvL85+sPr8J/Da/b/JH/f1STNv8+af/E8/647j82Eo+KWkZ+8M0yOn5Ph/frt7+XvWKbkWvy+U4nO7LQElv+1E8fgBuBsClT/pPplNvO/Du80m3/wc=", + "debug_symbols": "pZbNjuowDIXfJesu4vyHVxkhVKCMKlUFdeBKV4h3v3ZtzzCLu0k3/U4J59QxCc3TnIfj4/Mwzpfrl9l9PM1xGadp/DxM11N/H68zfvo0li5QzQ464ywDGI7hzc4hAiMyEiMzitl5RF3hLQMYmBIQnhEYkZEYmBIRhVFXBMsAhmN4RmBgSkIkRmYURl0RMSUjMKUgHMMzAiMyMKUiMqMwqC+2M8kKQeiEXhiEmAXYs5SEWViElZkpDxuXKQ+blJ3QC4MwCikPO5UpD2eei7AyixWCkPJw+oXycP4lCKMwCbOQ8rAJpTKrFYLQCSkP+1KDMAqTMAsxz2E/KuY5nC9YqwJUOBVeBa0wR4LWmCeRVGQVFBxIUDLOFMCqABVOhVdByYkEJWcSSUVWQcn59eqMbo/DfRkG2h1v+wV30a1fhvludvNjmjrzp58e65e+bv288t4vOIqTH+YzEgMv4zSQenU/bvt/K1DNqxn8jz22+ENt8aek/gzb/LWlfmez+B24bX7fUr8LRf3Rb/PnpvpLVX8Nm/weWur3XhevDy31+/j9/BS2+UtL/cFq/cHGbX7XUn8IoP6QtvlTU/3Fqb+UTf5oW/zx+/8nNu2/N39s8ifdfzH7bf7asv6T1fWbIG7z+yZ/1N8vxbLNn3/793jXn8bl1wnyRUnL2B+nQW4vj/n0Nnr/e9MRPYHelutpOD+WgZLejqF4/QA8OOArbE/v5PW2duBh/6LH/wM=", "file_map": { "50": { - "source": "fn main(x: u128, y: u128, z: u8) {\n let const_x = 12345;\n let const_y = 2345678;\n let const_z = 2;\n\n assert_eq(x + y, const_x + const_y);\n assert_eq(y - x, const_y - const_x);\n assert_eq(x * y, const_x * const_y);\n assert_eq(y / x, const_y / const_x);\n assert_eq(y % x, const_y % const_x);\n assert_eq(!x, !const_x);\n assert_eq(x ^ y, const_x ^ const_y);\n assert_eq(x & y, const_x & const_y);\n assert_eq(x | y, const_x | const_y);\n assert_eq(x >> z, const_x >> const_z);\n assert_eq(x << z, const_x << const_z);\n assert_eq(x < y, const_x < const_y);\n assert_eq(x <= y, const_x <= const_y);\n assert_eq(x != y, const_x != const_y);\n assert_eq(y > x, const_y > const_x);\n assert_eq(y >= x, const_y >= const_x);\n}\n", + "source": "fn main(x: u128, y: u128, z: u128) {\n let const_x = 12345;\n let const_y = 2345678;\n let const_z = 2;\n\n assert_eq(x + y, const_x + const_y);\n assert_eq(y - x, const_y - const_x);\n assert_eq(x * y, const_x * const_y);\n assert_eq(y / x, const_y / const_x);\n assert_eq(y % x, const_y % const_x);\n assert_eq(!x, !const_x);\n assert_eq(x ^ y, const_x ^ const_y);\n assert_eq(x & y, const_x & const_y);\n assert_eq(x | y, const_x | const_y);\n assert_eq(x >> z, const_x >> const_z);\n assert_eq(x << z, const_x << const_z);\n assert_eq(x < y, const_x < const_y);\n assert_eq(x <= y, const_x <= const_y);\n assert_eq(x != y, const_x != const_y);\n assert_eq(y > x, const_y > const_x);\n assert_eq(y >= x, const_y >= const_x);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__expanded.snap index 4f9707163f5..9b9cdd93e64 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__expanded.snap @@ -21,9 +21,9 @@ fn test_u16(x: u16) { let t4: u16 = t - t2; assert(t4 == t1); let mut small_int: u16 = x as u16; - let shift: u16 = small_int << (x as u8); + let shift: u16 = small_int << x; assert(shift == 8_u16); - assert((shift >> (x as u8)) == small_int); - assert((shift >> 15_u8) == 0_u16); - assert((shift << 15_u8) == 0_u16); + assert((shift >> x) == small_int); + assert((shift >> 15_u16) == 0_u16); + assert((shift << 15_u16) == 0_u16); } diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 93a5279ff2a..92ba177ba10 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -19,14 +19,14 @@ expression: artifact ], "return_type": null, "error_types": { - "5795655218219125583": { - "error_kind": "string", - "string": "Field failed to decompose into specified 8 limbs" - }, "14514982005979867414": { "error_kind": "string", "string": "attempt to bit-shift with overflow" }, + "16061458491050355795": { + "error_kind": "string", + "string": "Field failed to decompose into specified 5 limbs" + }, "17843811134343075018": { "error_kind": "string", "string": "Stack too deep" @@ -35,107 +35,57 @@ expression: artifact }, "bytecode": [ "func 0", - "current witness index : _74", + "current witness index : _29", "private parameters indices : [_0]", "public parameters indices : []", "return value indices : []", "BLACKBOX::RANGE [(_0, 16)] []", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 256 ]], outputs: [_1, _2]", - "BLACKBOX::RANGE [(_1, 8)] []", - "BLACKBOX::RANGE [(_2, 8)] []", - "EXPR [ (1, _0) (-256, _1) (-1, _2) 0 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _2) 240 ], EXPR [ 256 ]], outputs: [_3, _4]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) 65520 ], EXPR [ 65536 ]], outputs: [_1, _2]", + "BLACKBOX::RANGE [(_2, 16)] []", + "EXPR [ (1, _0) (-65536, _1) (-1, _2) 65520 ]", + "EXPR [ (-1, _1) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 5 ], EXPR [ 2 ]], outputs: [[_3, _4, _5, _6, _7]]", "BLACKBOX::RANGE [(_3, 1)] []", - "BLACKBOX::RANGE [(_4, 8)] []", - "EXPR [ (1, _2) (-256, _3) (-1, _4) 240 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_5, _6, _7, _8, _9, _10, _11, _12]]", + "BLACKBOX::RANGE [(_4, 1)] []", "BLACKBOX::RANGE [(_5, 1)] []", "BLACKBOX::RANGE [(_6, 1)] []", "BLACKBOX::RANGE [(_7, 1)] []", - "BLACKBOX::RANGE [(_8, 1)] []", - "BLACKBOX::RANGE [(_9, 1)] []", - "BLACKBOX::RANGE [(_10, 1)] []", - "BLACKBOX::RANGE [(_11, 1)] []", - "BLACKBOX::RANGE [(_12, 1)] []", - "EXPR [ (1, _2) (-1, _5) (-2, _6) (-4, _7) (-8, _8) (-16, _9) (-32, _10) (-64, _11) (-128, _12) 0 ]", - "EXPR [ (1, _12, _12) (2, _12) (-1, _13) 1 ]", - "EXPR [ (-1, _11) (-1, _14) 1 ]", - "EXPR [ (2, _11, _13) (1, _13, _14) (-1, _15) 0 ]", - "EXPR [ (1, _15, _15) (-1, _16) 0 ]", - "EXPR [ (-1, _10) (-1, _17) 1 ]", - "EXPR [ (2, _10, _16) (1, _16, _17) (-1, _18) 0 ]", - "EXPR [ (1, _18, _18) (-1, _19) 0 ]", - "EXPR [ (-1, _9) (-1, _20) 1 ]", - "EXPR [ (2, _9, _19) (1, _19, _20) (-1, _21) 0 ]", - "EXPR [ (1, _21, _21) (-1, _22) 0 ]", - "EXPR [ (-1, _8) (-1, _23) 1 ]", - "EXPR [ (2, _8, _22) (1, _22, _23) (-1, _24) 0 ]", - "EXPR [ (1, _24, _24) (-1, _25) 0 ]", - "EXPR [ (-1, _7) (-1, _26) 1 ]", - "EXPR [ (2, _7, _25) (1, _25, _26) (-1, _27) 0 ]", - "EXPR [ (1, _27, _27) (-1, _28) 0 ]", - "EXPR [ (-1, _6) (-1, _29) 1 ]", - "EXPR [ (2, _6, _28) (1, _28, _29) (-1, _30) 0 ]", - "EXPR [ (1, _30, _30) (-1, _31) 0 ]", - "EXPR [ (-1, _5) (-1, _32) 1 ]", - "EXPR [ (-1, _3) (-1, _33) 1 ]", - "EXPR [ (2, _5, _31) (1, _31, _32) (-1, _34) 0 ]", - "EXPR [ (1, _33, _34) (-1, _35) 0 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0, _35) 0 ], EXPR [ 65536 ]], outputs: [_36, _37]", - "BLACKBOX::RANGE [(_36, 238)] []", - "EXPR [ (1, _0, _35) (-65536, _36) (-1, _37) 0 ]", - "EXPR [ (-1, _36) (-1, _38) 333988080930164722019140712665668870369695501715332555293246523843014656 ]", - "BLACKBOX::RANGE [(_38, 238)] []", - "BRILLIG CALL func 3: inputs: [EXPR [ (-1, _36) 333988080930164722019140712665668870369695501715332555293246523843014656 ]], outputs: [_39]", - "EXPR [ (-1, _36, _39) (333988080930164722019140712665668870369695501715332555293246523843014656, _39) (1, _40) -1 ]", - "EXPR [ (-1, _36, _40) (333988080930164722019140712665668870369695501715332555293246523843014656, _40) 0 ]", - "EXPR [ (1, _37, _40) (-1, _41) 0 ]", - "BLACKBOX::RANGE [(_41, 0)] []", - "EXPR [ (1, _33) -1 ]", - "EXPR [ (1, _37) -8 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_42, _43, _44, _45, _46, _47, _48, _49]]", - "BLACKBOX::RANGE [(_42, 1)] []", - "BLACKBOX::RANGE [(_43, 1)] []", - "BLACKBOX::RANGE [(_44, 1)] []", - "BLACKBOX::RANGE [(_45, 1)] []", - "BLACKBOX::RANGE [(_46, 1)] []", - "BLACKBOX::RANGE [(_47, 1)] []", - "BLACKBOX::RANGE [(_48, 1)] []", - "BLACKBOX::RANGE [(_49, 1)] []", - "EXPR [ (1, _2) (-1, _42) (-2, _43) (-4, _44) (-8, _45) (-16, _46) (-32, _47) (-64, _48) (-128, _49) 0 ]", - "EXPR [ (1, _49, _49) (2, _49) (-1, _50) 1 ]", - "EXPR [ (-1, _48) (-1, _51) 1 ]", - "EXPR [ (2, _48, _50) (1, _50, _51) (-1, _52) 0 ]", - "EXPR [ (1, _52, _52) (-1, _53) 0 ]", - "EXPR [ (-1, _47) (-1, _54) 1 ]", - "EXPR [ (2, _47, _53) (1, _53, _54) (-1, _55) 0 ]", - "EXPR [ (1, _55, _55) (-1, _56) 0 ]", - "EXPR [ (-1, _46) (-1, _57) 1 ]", - "EXPR [ (2, _46, _56) (1, _56, _57) (-1, _58) 0 ]", - "EXPR [ (1, _58, _58) (-1, _59) 0 ]", - "EXPR [ (-1, _45) (-1, _60) 1 ]", - "EXPR [ (2, _45, _59) (1, _59, _60) (-1, _61) 0 ]", - "EXPR [ (1, _61, _61) (-1, _62) 0 ]", - "EXPR [ (-1, _44) (-1, _63) 1 ]", - "EXPR [ (2, _44, _62) (1, _62, _63) (-1, _64) 0 ]", - "EXPR [ (1, _64, _64) (-1, _65) 0 ]", - "EXPR [ (-1, _43) (-1, _66) 1 ]", - "EXPR [ (2, _43, _65) (1, _65, _66) (-1, _67) 0 ]", - "EXPR [ (1, _67, _67) (-1, _68) 0 ]", - "EXPR [ (-1, _42) (-1, _69) 1 ]", - "BRILLIG CALL func 3: inputs: [EXPR [ (2, _68, _42) (1, _68, _69) 0 ]], outputs: [_70]", - "EXPR [ (2, _42, _68) (1, _68, _69) (-1, _71) 0 ]", - "EXPR [ (1, _70, _71) -1 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ 8 ], EXPR [ (1, _71) 0 ]], outputs: [_72, _73]", - "BLACKBOX::RANGE [(_72, 16)] []", - "BLACKBOX::RANGE [(_73, 16)] []", - "EXPR [ (1, _71) (-1, _73) (-1, _74) -1 ]", - "BLACKBOX::RANGE [(_74, 16)] []", - "EXPR [ (-1, _71, _72) (-1, _73) 8 ]", - "EXPR [ (-1, _0) (1, _72) 0 ]", + "EXPR [ (1, _0) (-1, _3) (-2, _4) (-4, _5) (-8, _6) (-16, _7) 0 ]", + "EXPR [ (1, _7, _7) (2, _7) (-1, _8) 1 ]", + "EXPR [ (-1, _6) (-1, _9) 1 ]", + "EXPR [ (2, _6, _8) (1, _8, _9) (-1, _10) 0 ]", + "EXPR [ (1, _10, _10) (-1, _11) 0 ]", + "EXPR [ (-1, _5) (-1, _12) 1 ]", + "EXPR [ (2, _5, _11) (1, _11, _12) (-1, _13) 0 ]", + "EXPR [ (1, _13, _13) (-1, _14) 0 ]", + "EXPR [ (-1, _4) (-1, _15) 1 ]", + "EXPR [ (2, _4, _14) (1, _14, _15) (-1, _16) 0 ]", + "EXPR [ (1, _16, _16) (-1, _17) 0 ]", + "EXPR [ (-1, _3) (-1, _18) 1 ]", + "EXPR [ (2, _3, _17) (1, _17, _18) (-1, _19) 0 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0, _19) 0 ], EXPR [ 65536 ]], outputs: [_20, _21]", + "BLACKBOX::RANGE [(_20, 238)] []", + "EXPR [ (1, _0, _19) (-65536, _20) (-1, _21) 0 ]", + "EXPR [ (-1, _20) (-1, _22) 333988080930164722019140712665668870369695501715332555293246523843014656 ]", + "BLACKBOX::RANGE [(_22, 238)] []", + "BRILLIG CALL func 3: inputs: [EXPR [ (-1, _20) 333988080930164722019140712665668870369695501715332555293246523843014656 ]], outputs: [_23]", + "EXPR [ (-1, _20, _23) (333988080930164722019140712665668870369695501715332555293246523843014656, _23) (1, _24) -1 ]", + "EXPR [ (-1, _20, _24) (333988080930164722019140712665668870369695501715332555293246523843014656, _24) 0 ]", + "EXPR [ (1, _21, _24) (-1, _25) 0 ]", + "BLACKBOX::RANGE [(_25, 0)] []", + "EXPR [ (1, _21) -8 ]", + "BRILLIG CALL func 3: inputs: [EXPR [ (1, _19) 0 ]], outputs: [_26]", + "EXPR [ (1, _19, _26) -1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ 8 ], EXPR [ (1, _19) 0 ]], outputs: [_27, _28]", + "BLACKBOX::RANGE [(_27, 16)] []", + "BLACKBOX::RANGE [(_28, 16)] []", + "EXPR [ (1, _19) (-1, _28) (-1, _29) -1 ]", + "BLACKBOX::RANGE [(_29, 16)] []", + "EXPR [ (-1, _19, _27) (-1, _28) 8 ]", + "EXPR [ (-1, _0) (1, _27) 0 ]", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U16) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 22 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(3), source: Direct(0) }, Mov { destination: Relative(4), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(2) }, Call { location: 28 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 27 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 22 }, Cast { destination: Relative(3), source: Relative(1), bit_size: Integer(U8) }, Cast { destination: Relative(2), source: Relative(3), bit_size: Integer(U16) }, Cast { destination: Relative(3), source: Relative(2), bit_size: Integer(U8) }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U8, lhs: Relative(3), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(5), location: 38 }, Call { location: 56 }, Const { destination: Relative(4), bit_size: Integer(U16), value: 8 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 43 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 48 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 15 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 55 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U16) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 22 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(3), source: Direct(0) }, Mov { destination: Relative(4), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(2) }, Call { location: 28 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 27 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 22 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U16, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(3), location: 34 }, Call { location: 53 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(1), rhs: Relative(1) }, Const { destination: Relative(3), bit_size: Integer(U16), value: 8 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 40 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 45 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U16), value: 15 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 52 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", "unconstrained func 1", "[Const { destination: Direct(10), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(11), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(10), offset_address: Direct(11) }, BinaryFieldOp { destination: Direct(2), op: IntegerDiv, lhs: Direct(0), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Mul, lhs: Direct(2), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Sub, lhs: Direct(0), rhs: Direct(1) }, Mov { destination: Direct(0), source: Direct(2) }, Stop { return_data: HeapVector { pointer: Direct(11), size: Direct(10) } }]", "unconstrained func 2", @@ -143,10 +93,10 @@ expression: artifact "unconstrained func 3", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "tdbdjqJAEIbhe+ljDuiq/vVWjDGozISEoGF0k43h3rea+nCdg0k2kD3xHcepx5Gmwae5tKfH57EbPq5fZrd/mtPY9X33eeyv5+beXQf57dPU5cF6s7OVsUETNUmT51CtkWdUGa41VkNmxxLWOI3XBE3UiOkkeY6rNVZDGlG8RJQg8ZqgiRpRoiTP8aIkidWQhjWipGmqzPKZj/exbctHfjsIcmhuzdgOd7MbHn1fmV9N/5j/6OvWDHPvzSiv1pVph4tUwI+ub8tPU/V3uv551MaIYZvSa9z/8zxnwjznvGY+Jsy7ul4x7ywv88Rr5nn5/M77bfNhzfHzdjl+ftX//z6/5v3ptXw/vnveuPp54+rnjaufN65+3rj6eePq5/+3+um1+S19Gz/Is+bcjd+vyXIls6KRhjVOU67Uch0OmqhJmqyxNWpRQhl1KCwLzEKz4Cw8gkfwCB7BI3gEj+ARPIJH8Bgew2N4DI/hMTyGx/AYHsNz8Bw8B8/Bc/AcPAfPwXPwHDwPz8Pz8Mo9pZwI5aZSNoT3aEAjmtCsDTVqUUIZhRfgBXgBXoAX4EV4EV6EF+FFeBFehBfhRXgRXoKX4CV4CV6Cl+AleAlegpfgZXgZXoaXiyd3+Fy8OJXtMnbNqW/LSV+2xWM4L3tAnt5/35ZXlm8ut/F6bi+PsS375e3rizzu5QpL8aBn/d6HyqfDVDbYHw==", + "debug_symbols": "tZXRboIwFIbfpddc9JxS2voqxhjUbiEhaBgsWYzvvtP+ZXNLTBbJbs4n4v9Je+BwVad4mF/33fByflOb7VUdxq7vu9d9fz62U3ce5Nur0qmQVRuqFDWAAzwQMlgDcsSVMhoggAED1IA4jaABHOCBkFGLpRaIxQoYMEANiKURNIBYnMADIcNqQCzudqvUsrz9NMaYVne3XtmFSzvGYVKbYe77Sr23/Zx/9HZph8ypHeWsrlQcTkIRvnR9TJ9u1XdaP46ScyVM3n/F7Z/zxvmSN4GfyNfalnxN9pk8hyVvwrq8fer6Q1PyVrt1eXrm/5mX7TeP0n5l9/zK7vmV3fMru+dXds//X/f818P3K76To/bYjT/HnwwNWS/nanKtc7W5Nrm6XH2uIVfSANKEOCFPEBAMBAXBQZAQLAwLl2uAhWFhWBgWhoVhYVgYFgOLgcWUpcCSRjFpzGIiDONMV+gLA5gGciYVcqHoiDGU81353o5de+hj2sO0y/NwXLZUDqePy3JmeedcxvMxnuYxpu2/e/FI3coDx26H7dxaU1m7u6V+fQI=", "file_map": { "50": { - "source": "fn main(x: u16) {\n test_u16(x);\n // Safety: testing context\n unsafe {\n test_u16_unconstrained(x);\n }\n}\n\nunconstrained fn test_u16_unconstrained(x: u16) {\n test_u16(x)\n}\n\nfn test_u16(x: u16) {\n let t1: u16 = 1234;\n let t2: u16 = 4321;\n let t = t1 + t2;\n\n let t4 = t - t2;\n assert(t4 == t1);\n\n let mut small_int = x as u16;\n let shift = small_int << (x as u8);\n assert(shift == 8);\n assert(shift >> (x as u8) == small_int);\n assert(shift >> 15 == 0);\n assert(shift << 15 == 0);\n}\n", + "source": "fn main(x: u16) {\n test_u16(x);\n // Safety: testing context\n unsafe {\n test_u16_unconstrained(x);\n }\n}\n\nunconstrained fn test_u16_unconstrained(x: u16) {\n test_u16(x)\n}\n\nfn test_u16(x: u16) {\n let t1: u16 = 1234;\n let t2: u16 = 4321;\n let t = t1 + t2;\n\n let t4 = t - t2;\n assert(t4 == t1);\n\n let mut small_int = x as u16;\n let shift = small_int << x;\n assert(shift == 8);\n assert(shift >> x == small_int);\n assert(shift >> 15 == 0);\n assert(shift << 15 == 0);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_false_inliner_0.snap index f04e5ccacf1..84539db4fbf 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_false_inliner_0.snap @@ -19,14 +19,14 @@ expression: artifact ], "return_type": null, "error_types": { - "5795655218219125583": { - "error_kind": "string", - "string": "Field failed to decompose into specified 8 limbs" - }, "14514982005979867414": { "error_kind": "string", "string": "attempt to bit-shift with overflow" }, + "16061458491050355795": { + "error_kind": "string", + "string": "Field failed to decompose into specified 5 limbs" + }, "17843811134343075018": { "error_kind": "string", "string": "Stack too deep" @@ -35,107 +35,57 @@ expression: artifact }, "bytecode": [ "func 0", - "current witness index : _74", + "current witness index : _29", "private parameters indices : [_0]", "public parameters indices : []", "return value indices : []", "BLACKBOX::RANGE [(_0, 16)] []", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 256 ]], outputs: [_1, _2]", - "BLACKBOX::RANGE [(_1, 8)] []", - "BLACKBOX::RANGE [(_2, 8)] []", - "EXPR [ (1, _0) (-256, _1) (-1, _2) 0 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _2) 240 ], EXPR [ 256 ]], outputs: [_3, _4]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) 65520 ], EXPR [ 65536 ]], outputs: [_1, _2]", + "BLACKBOX::RANGE [(_2, 16)] []", + "EXPR [ (1, _0) (-65536, _1) (-1, _2) 65520 ]", + "EXPR [ (-1, _1) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 5 ], EXPR [ 2 ]], outputs: [[_3, _4, _5, _6, _7]]", "BLACKBOX::RANGE [(_3, 1)] []", - "BLACKBOX::RANGE [(_4, 8)] []", - "EXPR [ (1, _2) (-256, _3) (-1, _4) 240 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_5, _6, _7, _8, _9, _10, _11, _12]]", + "BLACKBOX::RANGE [(_4, 1)] []", "BLACKBOX::RANGE [(_5, 1)] []", "BLACKBOX::RANGE [(_6, 1)] []", "BLACKBOX::RANGE [(_7, 1)] []", - "BLACKBOX::RANGE [(_8, 1)] []", - "BLACKBOX::RANGE [(_9, 1)] []", - "BLACKBOX::RANGE [(_10, 1)] []", - "BLACKBOX::RANGE [(_11, 1)] []", - "BLACKBOX::RANGE [(_12, 1)] []", - "EXPR [ (1, _2) (-1, _5) (-2, _6) (-4, _7) (-8, _8) (-16, _9) (-32, _10) (-64, _11) (-128, _12) 0 ]", - "EXPR [ (1, _12, _12) (2, _12) (-1, _13) 1 ]", - "EXPR [ (-1, _11) (-1, _14) 1 ]", - "EXPR [ (2, _11, _13) (1, _13, _14) (-1, _15) 0 ]", - "EXPR [ (1, _15, _15) (-1, _16) 0 ]", - "EXPR [ (-1, _10) (-1, _17) 1 ]", - "EXPR [ (2, _10, _16) (1, _16, _17) (-1, _18) 0 ]", - "EXPR [ (1, _18, _18) (-1, _19) 0 ]", - "EXPR [ (-1, _9) (-1, _20) 1 ]", - "EXPR [ (2, _9, _19) (1, _19, _20) (-1, _21) 0 ]", - "EXPR [ (1, _21, _21) (-1, _22) 0 ]", - "EXPR [ (-1, _8) (-1, _23) 1 ]", - "EXPR [ (2, _8, _22) (1, _22, _23) (-1, _24) 0 ]", - "EXPR [ (1, _24, _24) (-1, _25) 0 ]", - "EXPR [ (-1, _7) (-1, _26) 1 ]", - "EXPR [ (2, _7, _25) (1, _25, _26) (-1, _27) 0 ]", - "EXPR [ (1, _27, _27) (-1, _28) 0 ]", - "EXPR [ (-1, _6) (-1, _29) 1 ]", - "EXPR [ (2, _6, _28) (1, _28, _29) (-1, _30) 0 ]", - "EXPR [ (1, _30, _30) (-1, _31) 0 ]", - "EXPR [ (-1, _5) (-1, _32) 1 ]", - "EXPR [ (-1, _3) (-1, _33) 1 ]", - "EXPR [ (2, _5, _31) (1, _31, _32) (-1, _34) 0 ]", - "EXPR [ (1, _33, _34) (-1, _35) 0 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0, _35) 0 ], EXPR [ 65536 ]], outputs: [_36, _37]", - "BLACKBOX::RANGE [(_36, 238)] []", - "EXPR [ (1, _0, _35) (-65536, _36) (-1, _37) 0 ]", - "EXPR [ (-1, _36) (-1, _38) 333988080930164722019140712665668870369695501715332555293246523843014656 ]", - "BLACKBOX::RANGE [(_38, 238)] []", - "BRILLIG CALL func 3: inputs: [EXPR [ (-1, _36) 333988080930164722019140712665668870369695501715332555293246523843014656 ]], outputs: [_39]", - "EXPR [ (-1, _36, _39) (333988080930164722019140712665668870369695501715332555293246523843014656, _39) (1, _40) -1 ]", - "EXPR [ (-1, _36, _40) (333988080930164722019140712665668870369695501715332555293246523843014656, _40) 0 ]", - "EXPR [ (1, _37, _40) (-1, _41) 0 ]", - "BLACKBOX::RANGE [(_41, 0)] []", - "EXPR [ (1, _33) -1 ]", - "EXPR [ (1, _37) -8 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_42, _43, _44, _45, _46, _47, _48, _49]]", - "BLACKBOX::RANGE [(_42, 1)] []", - "BLACKBOX::RANGE [(_43, 1)] []", - "BLACKBOX::RANGE [(_44, 1)] []", - "BLACKBOX::RANGE [(_45, 1)] []", - "BLACKBOX::RANGE [(_46, 1)] []", - "BLACKBOX::RANGE [(_47, 1)] []", - "BLACKBOX::RANGE [(_48, 1)] []", - "BLACKBOX::RANGE [(_49, 1)] []", - "EXPR [ (1, _2) (-1, _42) (-2, _43) (-4, _44) (-8, _45) (-16, _46) (-32, _47) (-64, _48) (-128, _49) 0 ]", - "EXPR [ (1, _49, _49) (2, _49) (-1, _50) 1 ]", - "EXPR [ (-1, _48) (-1, _51) 1 ]", - "EXPR [ (2, _48, _50) (1, _50, _51) (-1, _52) 0 ]", - "EXPR [ (1, _52, _52) (-1, _53) 0 ]", - "EXPR [ (-1, _47) (-1, _54) 1 ]", - "EXPR [ (2, _47, _53) (1, _53, _54) (-1, _55) 0 ]", - "EXPR [ (1, _55, _55) (-1, _56) 0 ]", - "EXPR [ (-1, _46) (-1, _57) 1 ]", - "EXPR [ (2, _46, _56) (1, _56, _57) (-1, _58) 0 ]", - "EXPR [ (1, _58, _58) (-1, _59) 0 ]", - "EXPR [ (-1, _45) (-1, _60) 1 ]", - "EXPR [ (2, _45, _59) (1, _59, _60) (-1, _61) 0 ]", - "EXPR [ (1, _61, _61) (-1, _62) 0 ]", - "EXPR [ (-1, _44) (-1, _63) 1 ]", - "EXPR [ (2, _44, _62) (1, _62, _63) (-1, _64) 0 ]", - "EXPR [ (1, _64, _64) (-1, _65) 0 ]", - "EXPR [ (-1, _43) (-1, _66) 1 ]", - "EXPR [ (2, _43, _65) (1, _65, _66) (-1, _67) 0 ]", - "EXPR [ (1, _67, _67) (-1, _68) 0 ]", - "EXPR [ (-1, _42) (-1, _69) 1 ]", - "BRILLIG CALL func 3: inputs: [EXPR [ (2, _68, _42) (1, _68, _69) 0 ]], outputs: [_70]", - "EXPR [ (2, _42, _68) (1, _68, _69) (-1, _71) 0 ]", - "EXPR [ (1, _70, _71) -1 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ 8 ], EXPR [ (1, _71) 0 ]], outputs: [_72, _73]", - "BLACKBOX::RANGE [(_72, 16)] []", - "BLACKBOX::RANGE [(_73, 16)] []", - "EXPR [ (1, _71) (-1, _73) (-1, _74) -1 ]", - "BLACKBOX::RANGE [(_74, 16)] []", - "EXPR [ (-1, _71, _72) (-1, _73) 8 ]", - "EXPR [ (-1, _0) (1, _72) 0 ]", + "EXPR [ (1, _0) (-1, _3) (-2, _4) (-4, _5) (-8, _6) (-16, _7) 0 ]", + "EXPR [ (1, _7, _7) (2, _7) (-1, _8) 1 ]", + "EXPR [ (-1, _6) (-1, _9) 1 ]", + "EXPR [ (2, _6, _8) (1, _8, _9) (-1, _10) 0 ]", + "EXPR [ (1, _10, _10) (-1, _11) 0 ]", + "EXPR [ (-1, _5) (-1, _12) 1 ]", + "EXPR [ (2, _5, _11) (1, _11, _12) (-1, _13) 0 ]", + "EXPR [ (1, _13, _13) (-1, _14) 0 ]", + "EXPR [ (-1, _4) (-1, _15) 1 ]", + "EXPR [ (2, _4, _14) (1, _14, _15) (-1, _16) 0 ]", + "EXPR [ (1, _16, _16) (-1, _17) 0 ]", + "EXPR [ (-1, _3) (-1, _18) 1 ]", + "EXPR [ (2, _3, _17) (1, _17, _18) (-1, _19) 0 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0, _19) 0 ], EXPR [ 65536 ]], outputs: [_20, _21]", + "BLACKBOX::RANGE [(_20, 238)] []", + "EXPR [ (1, _0, _19) (-65536, _20) (-1, _21) 0 ]", + "EXPR [ (-1, _20) (-1, _22) 333988080930164722019140712665668870369695501715332555293246523843014656 ]", + "BLACKBOX::RANGE [(_22, 238)] []", + "BRILLIG CALL func 3: inputs: [EXPR [ (-1, _20) 333988080930164722019140712665668870369695501715332555293246523843014656 ]], outputs: [_23]", + "EXPR [ (-1, _20, _23) (333988080930164722019140712665668870369695501715332555293246523843014656, _23) (1, _24) -1 ]", + "EXPR [ (-1, _20, _24) (333988080930164722019140712665668870369695501715332555293246523843014656, _24) 0 ]", + "EXPR [ (1, _21, _24) (-1, _25) 0 ]", + "BLACKBOX::RANGE [(_25, 0)] []", + "EXPR [ (1, _21) -8 ]", + "BRILLIG CALL func 3: inputs: [EXPR [ (1, _19) 0 ]], outputs: [_26]", + "EXPR [ (1, _19, _26) -1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ 8 ], EXPR [ (1, _19) 0 ]], outputs: [_27, _28]", + "BLACKBOX::RANGE [(_27, 16)] []", + "BLACKBOX::RANGE [(_28, 16)] []", + "EXPR [ (1, _19) (-1, _28) (-1, _29) -1 ]", + "BLACKBOX::RANGE [(_29, 16)] []", + "EXPR [ (-1, _19, _27) (-1, _28) 8 ]", + "EXPR [ (-1, _0) (1, _27) 0 ]", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U16) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 42 }, Cast { destination: Relative(3), source: Relative(1), bit_size: Integer(U8) }, Cast { destination: Relative(2), source: Relative(3), bit_size: Integer(U16) }, Cast { destination: Relative(3), source: Relative(2), bit_size: Integer(U8) }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U8, lhs: Relative(3), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(5), location: 24 }, Call { location: 48 }, Const { destination: Relative(4), bit_size: Integer(U16), value: 8 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 29 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 34 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 15 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 41 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 47 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U16) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 39 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U16, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(3), location: 20 }, Call { location: 45 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(1), rhs: Relative(1) }, Const { destination: Relative(3), bit_size: Integer(U16), value: 8 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 26 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 31 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U16), value: 15 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 38 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 44 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", "unconstrained func 1", "[Const { destination: Direct(10), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(11), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(10), offset_address: Direct(11) }, BinaryFieldOp { destination: Direct(2), op: IntegerDiv, lhs: Direct(0), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Mul, lhs: Direct(2), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Sub, lhs: Direct(0), rhs: Direct(1) }, Mov { destination: Direct(0), source: Direct(2) }, Stop { return_data: HeapVector { pointer: Direct(11), size: Direct(10) } }]", "unconstrained func 2", @@ -143,10 +93,10 @@ expression: artifact "unconstrained func 3", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "tdZNjuIwEIbhu3idRezyT5mrIIQCpFuRooDSMNII5e5Tpr4wsGAWiWbD2zRdD20cA3dzag+37303fJ1/zGZ7N4ex6/vue9+fj821Ow/y27upy40NZuMqY6MmadhsSJIfcbXGapyGNN5svCRooiZpWCNKqAyJEiVW4zSkESVJgkYUliQNa/IjXhSepsrMK9lfx7YtC3lZmiz40oztcDWb4db3lfnV9LfHH/1cmuHRazPKo3Vl2uEkFfCr69vy01T9na4/j9qUMGyZn+Phfd5+nqfsME85L5lPjHlf1wvmvaV53tGSeZrX70NYNx+XvH7Bzq9fWPT/v85/fP5/7L97bt/HZ88rdz+v3P28cvfzyt3PK3c/r9z9/P92n5+H37q38Z3ca47d+P5OK+95VjSnIY3XhIJUJmqShjVZY2vUog4l1KOwLDALzYKz8Bw8B8/Bc/AcPAfPwXPwHDwHj+ARPIJH8AgewSN4BI/gETwPz8Pz8Dw8D8/D8/A8PA/PwwvwArwALxRPLoRQPDkQIaARTSijWRtr1KIOJRRehBfhRXgRXoSX4CV4CV6Cl+AleAlegpfgJXgMj+ExPIbH8Bgew2N4DI/hZXgZXoaXiyef8Ll4aSrHZeyaQ9+Wi74ci9twnM+A3L3+vsyPzN9HLuP52J5uY1vOy8uXErndelf5tNOrfuu5CvVuKgfsDw==", + "debug_symbols": "tZVBjuIwEEXv4nUWrrId21wFIRTA3YoUBZROWhoh7j5lf6eneyRmQTSbekD4D7uKOHd1Safl/diPb9cPtdvf1Wnqh6F/Pw7Xczf311E+vSudCzm140ZRC3ggALGANUBqZwQMGMACDhCLFYjFCQIQC4wGxNIKGBCLF1jAAS0gFv94NGpd9HGeUspr/rYL2dutm9I4q924DEOjPrthKV/6uHVj4dxNclU3Ko0XoQjf+iHlV4/mT1o/j5L3NUwhfMXdzzw9zxsfat5EfiFvtat5S+6VPMc1b+K2vHtp/bGteaf9tjw9/f1/zI95bb95lg4bpxc2Ti9snF7YOL2wcXrh/00vfN18f8UP8q4799PPQ02OF9kvl2pKtaW6UttSfamh1FgqaQBpQpyQJwgIBoKC4CBICBaGhesaYGFYGBaGhWFhWBgWhsXAYmAxdSuw5IOSNE5KIhyVhb4yVEbQ6kqq5ErRkdwWNvvyv/Kzm/ruNKTcw9zlZTyvLZW386/bemV9ktym6zldlinl9n97nEjdm9hYe0A799Y11h8eeV6/AQ==", "file_map": { "50": { - "source": "fn main(x: u16) {\n test_u16(x);\n // Safety: testing context\n unsafe {\n test_u16_unconstrained(x);\n }\n}\n\nunconstrained fn test_u16_unconstrained(x: u16) {\n test_u16(x)\n}\n\nfn test_u16(x: u16) {\n let t1: u16 = 1234;\n let t2: u16 = 4321;\n let t = t1 + t2;\n\n let t4 = t - t2;\n assert(t4 == t1);\n\n let mut small_int = x as u16;\n let shift = small_int << (x as u8);\n assert(shift == 8);\n assert(shift >> (x as u8) == small_int);\n assert(shift >> 15 == 0);\n assert(shift << 15 == 0);\n}\n", + "source": "fn main(x: u16) {\n test_u16(x);\n // Safety: testing context\n unsafe {\n test_u16_unconstrained(x);\n }\n}\n\nunconstrained fn test_u16_unconstrained(x: u16) {\n test_u16(x)\n}\n\nfn test_u16(x: u16) {\n let t1: u16 = 1234;\n let t2: u16 = 4321;\n let t = t1 + t2;\n\n let t4 = t - t2;\n assert(t4 == t1);\n\n let mut small_int = x as u16;\n let shift = small_int << x;\n assert(shift == 8);\n assert(shift >> x == small_int);\n assert(shift >> 15 == 0);\n assert(shift << 15 == 0);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index f04e5ccacf1..84539db4fbf 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -19,14 +19,14 @@ expression: artifact ], "return_type": null, "error_types": { - "5795655218219125583": { - "error_kind": "string", - "string": "Field failed to decompose into specified 8 limbs" - }, "14514982005979867414": { "error_kind": "string", "string": "attempt to bit-shift with overflow" }, + "16061458491050355795": { + "error_kind": "string", + "string": "Field failed to decompose into specified 5 limbs" + }, "17843811134343075018": { "error_kind": "string", "string": "Stack too deep" @@ -35,107 +35,57 @@ expression: artifact }, "bytecode": [ "func 0", - "current witness index : _74", + "current witness index : _29", "private parameters indices : [_0]", "public parameters indices : []", "return value indices : []", "BLACKBOX::RANGE [(_0, 16)] []", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 256 ]], outputs: [_1, _2]", - "BLACKBOX::RANGE [(_1, 8)] []", - "BLACKBOX::RANGE [(_2, 8)] []", - "EXPR [ (1, _0) (-256, _1) (-1, _2) 0 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _2) 240 ], EXPR [ 256 ]], outputs: [_3, _4]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0) 65520 ], EXPR [ 65536 ]], outputs: [_1, _2]", + "BLACKBOX::RANGE [(_2, 16)] []", + "EXPR [ (1, _0) (-65536, _1) (-1, _2) 65520 ]", + "EXPR [ (-1, _1) 0 ]", + "BRILLIG CALL func 2: inputs: [EXPR [ (1, _0) 0 ], EXPR [ 5 ], EXPR [ 2 ]], outputs: [[_3, _4, _5, _6, _7]]", "BLACKBOX::RANGE [(_3, 1)] []", - "BLACKBOX::RANGE [(_4, 8)] []", - "EXPR [ (1, _2) (-256, _3) (-1, _4) 240 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_5, _6, _7, _8, _9, _10, _11, _12]]", + "BLACKBOX::RANGE [(_4, 1)] []", "BLACKBOX::RANGE [(_5, 1)] []", "BLACKBOX::RANGE [(_6, 1)] []", "BLACKBOX::RANGE [(_7, 1)] []", - "BLACKBOX::RANGE [(_8, 1)] []", - "BLACKBOX::RANGE [(_9, 1)] []", - "BLACKBOX::RANGE [(_10, 1)] []", - "BLACKBOX::RANGE [(_11, 1)] []", - "BLACKBOX::RANGE [(_12, 1)] []", - "EXPR [ (1, _2) (-1, _5) (-2, _6) (-4, _7) (-8, _8) (-16, _9) (-32, _10) (-64, _11) (-128, _12) 0 ]", - "EXPR [ (1, _12, _12) (2, _12) (-1, _13) 1 ]", - "EXPR [ (-1, _11) (-1, _14) 1 ]", - "EXPR [ (2, _11, _13) (1, _13, _14) (-1, _15) 0 ]", - "EXPR [ (1, _15, _15) (-1, _16) 0 ]", - "EXPR [ (-1, _10) (-1, _17) 1 ]", - "EXPR [ (2, _10, _16) (1, _16, _17) (-1, _18) 0 ]", - "EXPR [ (1, _18, _18) (-1, _19) 0 ]", - "EXPR [ (-1, _9) (-1, _20) 1 ]", - "EXPR [ (2, _9, _19) (1, _19, _20) (-1, _21) 0 ]", - "EXPR [ (1, _21, _21) (-1, _22) 0 ]", - "EXPR [ (-1, _8) (-1, _23) 1 ]", - "EXPR [ (2, _8, _22) (1, _22, _23) (-1, _24) 0 ]", - "EXPR [ (1, _24, _24) (-1, _25) 0 ]", - "EXPR [ (-1, _7) (-1, _26) 1 ]", - "EXPR [ (2, _7, _25) (1, _25, _26) (-1, _27) 0 ]", - "EXPR [ (1, _27, _27) (-1, _28) 0 ]", - "EXPR [ (-1, _6) (-1, _29) 1 ]", - "EXPR [ (2, _6, _28) (1, _28, _29) (-1, _30) 0 ]", - "EXPR [ (1, _30, _30) (-1, _31) 0 ]", - "EXPR [ (-1, _5) (-1, _32) 1 ]", - "EXPR [ (-1, _3) (-1, _33) 1 ]", - "EXPR [ (2, _5, _31) (1, _31, _32) (-1, _34) 0 ]", - "EXPR [ (1, _33, _34) (-1, _35) 0 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0, _35) 0 ], EXPR [ 65536 ]], outputs: [_36, _37]", - "BLACKBOX::RANGE [(_36, 238)] []", - "EXPR [ (1, _0, _35) (-65536, _36) (-1, _37) 0 ]", - "EXPR [ (-1, _36) (-1, _38) 333988080930164722019140712665668870369695501715332555293246523843014656 ]", - "BLACKBOX::RANGE [(_38, 238)] []", - "BRILLIG CALL func 3: inputs: [EXPR [ (-1, _36) 333988080930164722019140712665668870369695501715332555293246523843014656 ]], outputs: [_39]", - "EXPR [ (-1, _36, _39) (333988080930164722019140712665668870369695501715332555293246523843014656, _39) (1, _40) -1 ]", - "EXPR [ (-1, _36, _40) (333988080930164722019140712665668870369695501715332555293246523843014656, _40) 0 ]", - "EXPR [ (1, _37, _40) (-1, _41) 0 ]", - "BLACKBOX::RANGE [(_41, 0)] []", - "EXPR [ (1, _33) -1 ]", - "EXPR [ (1, _37) -8 ]", - "BRILLIG CALL func 2: inputs: [EXPR [ (1, _2) 0 ], EXPR [ 8 ], EXPR [ 2 ]], outputs: [[_42, _43, _44, _45, _46, _47, _48, _49]]", - "BLACKBOX::RANGE [(_42, 1)] []", - "BLACKBOX::RANGE [(_43, 1)] []", - "BLACKBOX::RANGE [(_44, 1)] []", - "BLACKBOX::RANGE [(_45, 1)] []", - "BLACKBOX::RANGE [(_46, 1)] []", - "BLACKBOX::RANGE [(_47, 1)] []", - "BLACKBOX::RANGE [(_48, 1)] []", - "BLACKBOX::RANGE [(_49, 1)] []", - "EXPR [ (1, _2) (-1, _42) (-2, _43) (-4, _44) (-8, _45) (-16, _46) (-32, _47) (-64, _48) (-128, _49) 0 ]", - "EXPR [ (1, _49, _49) (2, _49) (-1, _50) 1 ]", - "EXPR [ (-1, _48) (-1, _51) 1 ]", - "EXPR [ (2, _48, _50) (1, _50, _51) (-1, _52) 0 ]", - "EXPR [ (1, _52, _52) (-1, _53) 0 ]", - "EXPR [ (-1, _47) (-1, _54) 1 ]", - "EXPR [ (2, _47, _53) (1, _53, _54) (-1, _55) 0 ]", - "EXPR [ (1, _55, _55) (-1, _56) 0 ]", - "EXPR [ (-1, _46) (-1, _57) 1 ]", - "EXPR [ (2, _46, _56) (1, _56, _57) (-1, _58) 0 ]", - "EXPR [ (1, _58, _58) (-1, _59) 0 ]", - "EXPR [ (-1, _45) (-1, _60) 1 ]", - "EXPR [ (2, _45, _59) (1, _59, _60) (-1, _61) 0 ]", - "EXPR [ (1, _61, _61) (-1, _62) 0 ]", - "EXPR [ (-1, _44) (-1, _63) 1 ]", - "EXPR [ (2, _44, _62) (1, _62, _63) (-1, _64) 0 ]", - "EXPR [ (1, _64, _64) (-1, _65) 0 ]", - "EXPR [ (-1, _43) (-1, _66) 1 ]", - "EXPR [ (2, _43, _65) (1, _65, _66) (-1, _67) 0 ]", - "EXPR [ (1, _67, _67) (-1, _68) 0 ]", - "EXPR [ (-1, _42) (-1, _69) 1 ]", - "BRILLIG CALL func 3: inputs: [EXPR [ (2, _68, _42) (1, _68, _69) 0 ]], outputs: [_70]", - "EXPR [ (2, _42, _68) (1, _68, _69) (-1, _71) 0 ]", - "EXPR [ (1, _70, _71) -1 ]", - "BRILLIG CALL func 1: inputs: [EXPR [ 8 ], EXPR [ (1, _71) 0 ]], outputs: [_72, _73]", - "BLACKBOX::RANGE [(_72, 16)] []", - "BLACKBOX::RANGE [(_73, 16)] []", - "EXPR [ (1, _71) (-1, _73) (-1, _74) -1 ]", - "BLACKBOX::RANGE [(_74, 16)] []", - "EXPR [ (-1, _71, _72) (-1, _73) 8 ]", - "EXPR [ (-1, _0) (1, _72) 0 ]", + "EXPR [ (1, _0) (-1, _3) (-2, _4) (-4, _5) (-8, _6) (-16, _7) 0 ]", + "EXPR [ (1, _7, _7) (2, _7) (-1, _8) 1 ]", + "EXPR [ (-1, _6) (-1, _9) 1 ]", + "EXPR [ (2, _6, _8) (1, _8, _9) (-1, _10) 0 ]", + "EXPR [ (1, _10, _10) (-1, _11) 0 ]", + "EXPR [ (-1, _5) (-1, _12) 1 ]", + "EXPR [ (2, _5, _11) (1, _11, _12) (-1, _13) 0 ]", + "EXPR [ (1, _13, _13) (-1, _14) 0 ]", + "EXPR [ (-1, _4) (-1, _15) 1 ]", + "EXPR [ (2, _4, _14) (1, _14, _15) (-1, _16) 0 ]", + "EXPR [ (1, _16, _16) (-1, _17) 0 ]", + "EXPR [ (-1, _3) (-1, _18) 1 ]", + "EXPR [ (2, _3, _17) (1, _17, _18) (-1, _19) 0 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ (1, _0, _19) 0 ], EXPR [ 65536 ]], outputs: [_20, _21]", + "BLACKBOX::RANGE [(_20, 238)] []", + "EXPR [ (1, _0, _19) (-65536, _20) (-1, _21) 0 ]", + "EXPR [ (-1, _20) (-1, _22) 333988080930164722019140712665668870369695501715332555293246523843014656 ]", + "BLACKBOX::RANGE [(_22, 238)] []", + "BRILLIG CALL func 3: inputs: [EXPR [ (-1, _20) 333988080930164722019140712665668870369695501715332555293246523843014656 ]], outputs: [_23]", + "EXPR [ (-1, _20, _23) (333988080930164722019140712665668870369695501715332555293246523843014656, _23) (1, _24) -1 ]", + "EXPR [ (-1, _20, _24) (333988080930164722019140712665668870369695501715332555293246523843014656, _24) 0 ]", + "EXPR [ (1, _21, _24) (-1, _25) 0 ]", + "BLACKBOX::RANGE [(_25, 0)] []", + "EXPR [ (1, _21) -8 ]", + "BRILLIG CALL func 3: inputs: [EXPR [ (1, _19) 0 ]], outputs: [_26]", + "EXPR [ (1, _19, _26) -1 ]", + "BRILLIG CALL func 1: inputs: [EXPR [ 8 ], EXPR [ (1, _19) 0 ]], outputs: [_27, _28]", + "BLACKBOX::RANGE [(_27, 16)] []", + "BLACKBOX::RANGE [(_28, 16)] []", + "EXPR [ (1, _19) (-1, _28) (-1, _29) -1 ]", + "BLACKBOX::RANGE [(_29, 16)] []", + "EXPR [ (-1, _19, _27) (-1, _28) 8 ]", + "EXPR [ (-1, _0) (1, _27) 0 ]", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U16) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 42 }, Cast { destination: Relative(3), source: Relative(1), bit_size: Integer(U8) }, Cast { destination: Relative(2), source: Relative(3), bit_size: Integer(U16) }, Cast { destination: Relative(3), source: Relative(2), bit_size: Integer(U8) }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U8, lhs: Relative(3), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(5), location: 24 }, Call { location: 48 }, Const { destination: Relative(4), bit_size: Integer(U16), value: 8 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 29 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 34 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 15 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 41 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 47 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U16) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 39 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U16, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(3), location: 20 }, Call { location: 45 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(1), rhs: Relative(1) }, Const { destination: Relative(3), bit_size: Integer(U16), value: 8 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 26 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 31 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U16), value: 15 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 38 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 44 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", "unconstrained func 1", "[Const { destination: Direct(10), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(11), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(10), offset_address: Direct(11) }, BinaryFieldOp { destination: Direct(2), op: IntegerDiv, lhs: Direct(0), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Mul, lhs: Direct(2), rhs: Direct(1) }, BinaryFieldOp { destination: Direct(1), op: Sub, lhs: Direct(0), rhs: Direct(1) }, Mov { destination: Direct(0), source: Direct(2) }, Stop { return_data: HeapVector { pointer: Direct(11), size: Direct(10) } }]", "unconstrained func 2", @@ -143,10 +93,10 @@ expression: artifact "unconstrained func 3", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "tdZNjuIwEIbhu3idRezyT5mrIIQCpFuRooDSMNII5e5Tpr4wsGAWiWbD2zRdD20cA3dzag+37303fJ1/zGZ7N4ex6/vue9+fj821Ow/y27upy40NZuMqY6MmadhsSJIfcbXGapyGNN5svCRooiZpWCNKqAyJEiVW4zSkESVJgkYUliQNa/IjXhSepsrMK9lfx7YtC3lZmiz40oztcDWb4db3lfnV9LfHH/1cmuHRazPKo3Vl2uEkFfCr69vy01T9na4/j9qUMGyZn+Phfd5+nqfsME85L5lPjHlf1wvmvaV53tGSeZrX70NYNx+XvH7Bzq9fWPT/v85/fP5/7L97bt/HZ88rdz+v3P28cvfzyt3PK3c/r9z9/P92n5+H37q38Z3ca47d+P5OK+95VjSnIY3XhIJUJmqShjVZY2vUog4l1KOwLDALzYKz8Bw8B8/Bc/AcPAfPwXPwHDwHj+ARPIJH8AgewSN4BI/gETwPz8Pz8Dw8D8/D8/A8PA/PwwvwArwALxRPLoRQPDkQIaARTSijWRtr1KIOJRRehBfhRXgRXoSX4CV4CV6Cl+AleAlegpfgJXgMj+ExPIbH8Bgew2N4DI/hZXgZXoaXiyef8Ll4aSrHZeyaQ9+Wi74ci9twnM+A3L3+vsyPzN9HLuP52J5uY1vOy8uXErndelf5tNOrfuu5CvVuKgfsDw==", + "debug_symbols": "tZVBjuIwEEXv4nUWrrId21wFIRTA3YoUBZROWhoh7j5lf6eneyRmQTSbekD4D7uKOHd1Safl/diPb9cPtdvf1Wnqh6F/Pw7Xczf311E+vSudCzm140ZRC3ggALGANUBqZwQMGMACDhCLFYjFCQIQC4wGxNIKGBCLF1jAAS0gFv94NGpd9HGeUspr/rYL2dutm9I4q924DEOjPrthKV/6uHVj4dxNclU3Ko0XoQjf+iHlV4/mT1o/j5L3NUwhfMXdzzw9zxsfat5EfiFvtat5S+6VPMc1b+K2vHtp/bGteaf9tjw9/f1/zI95bb95lg4bpxc2Ti9snF7YOL2wcXrh/00vfN18f8UP8q4799PPQ02OF9kvl2pKtaW6UttSfamh1FgqaQBpQpyQJwgIBoKC4CBICBaGhesaYGFYGBaGhWFhWBgWhsXAYmAxdSuw5IOSNE5KIhyVhb4yVEbQ6kqq5ErRkdwWNvvyv/Kzm/ruNKTcw9zlZTyvLZW386/bemV9ktym6zldlinl9n97nEjdm9hYe0A799Y11h8eeV6/AQ==", "file_map": { "50": { - "source": "fn main(x: u16) {\n test_u16(x);\n // Safety: testing context\n unsafe {\n test_u16_unconstrained(x);\n }\n}\n\nunconstrained fn test_u16_unconstrained(x: u16) {\n test_u16(x)\n}\n\nfn test_u16(x: u16) {\n let t1: u16 = 1234;\n let t2: u16 = 4321;\n let t = t1 + t2;\n\n let t4 = t - t2;\n assert(t4 == t1);\n\n let mut small_int = x as u16;\n let shift = small_int << (x as u8);\n assert(shift == 8);\n assert(shift >> (x as u8) == small_int);\n assert(shift >> 15 == 0);\n assert(shift << 15 == 0);\n}\n", + "source": "fn main(x: u16) {\n test_u16(x);\n // Safety: testing context\n unsafe {\n test_u16_unconstrained(x);\n }\n}\n\nunconstrained fn test_u16_unconstrained(x: u16) {\n test_u16(x)\n}\n\nfn test_u16(x: u16) {\n let t1: u16 = 1234;\n let t2: u16 = 4321;\n let t = t1 + t2;\n\n let t4 = t - t2;\n assert(t4 == t1);\n\n let mut small_int = x as u16;\n let shift = small_int << x;\n assert(shift == 8);\n assert(shift >> x == small_int);\n assert(shift >> 15 == 0);\n assert(shift << 15 == 0);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 2ba6c73c0dc..5c66acfc8ab 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -37,12 +37,12 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U16) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 22 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(3), source: Direct(0) }, Mov { destination: Relative(4), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(2) }, Call { location: 28 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 27 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 22 }, Cast { destination: Relative(3), source: Relative(1), bit_size: Integer(U8) }, Cast { destination: Relative(2), source: Relative(3), bit_size: Integer(U16) }, Cast { destination: Relative(3), source: Relative(2), bit_size: Integer(U8) }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U8, lhs: Relative(3), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(5), location: 38 }, Call { location: 56 }, Const { destination: Relative(4), bit_size: Integer(U16), value: 8 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 43 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 48 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 15 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 55 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U16) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 22 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(3), source: Direct(0) }, Mov { destination: Relative(4), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(2) }, Call { location: 28 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 27 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 22 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U16, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(3), location: 34 }, Call { location: 53 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(1), rhs: Relative(1) }, Const { destination: Relative(3), bit_size: Integer(U16), value: 8 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 40 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 45 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U16), value: 15 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 52 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pdPdjkQwGAbge+lxD/qjilsRkaImTZqSDptsxL3vx8esOdhkY048qt4XjS6ks838qF3ohycpyoU00XnvHrUfWjO5IcDVhbDtwBUpOCU8RTSSIfmOYAiMBCWSIRwRpJCARBJEISmiEehMgHwnYQhHBAItCoCWFFBIimgEWjSQ7yhoyQCOCEQi0JKtKyXnN9dTtHb75MsiwNKMJtowkSLM3lPyZfy83/QcTdidTIRZRokNHQiFvfN2O1vpb5r9HRXiyEr5Cqt/p2X+iuf5nbzOjnzC2I18wuWZF3feP5H6zCv1WT7NbuQVP9dP3Xr/a/79+RWMTOvi26Zat6boTOPtMezn0F5mp+/xnDk35RiH1nZztFvTZWfCsYSfR+gKtiL84qVKqcqqdXv0Dw==", + "debug_symbols": "pdPRioQgFAbgd/HaC9PM7FUiwsoGQSycWliid99Tp3abi4Whuekbx/6/rFxIZ5v5UbvQD09SlAtpovPePWo/tGZyQ4B/F8K2QyJJkVCSZIhCckTvcIbAiFMiGJIgHBFIikCnADJEITmid1JoSQFokQBHBJIi0JIBGQItCsgRvSMZAi1qXSk5l1dP0dptdZf1wlMYTbRhIkWYvafky/h5P+k5mrA7mQizjBIbOhAKe+ft9mulf2n2f5TzIyvEb1i+nRYqP+Oa38inTB75NJF38lyfeaE/y8tb96+zIy+Z+iyfvF6/gpFpXXz5/tetKTrTeHsM+zm0l9npezxnzv0zxqG13Rzt1nTZRHAs4eVzVcGuga+xlIJKWa3bpX8A", "file_map": { "50": { - "source": "fn main(x: u16) {\n test_u16(x);\n // Safety: testing context\n unsafe {\n test_u16_unconstrained(x);\n }\n}\n\nunconstrained fn test_u16_unconstrained(x: u16) {\n test_u16(x)\n}\n\nfn test_u16(x: u16) {\n let t1: u16 = 1234;\n let t2: u16 = 4321;\n let t = t1 + t2;\n\n let t4 = t - t2;\n assert(t4 == t1);\n\n let mut small_int = x as u16;\n let shift = small_int << (x as u8);\n assert(shift == 8);\n assert(shift >> (x as u8) == small_int);\n assert(shift >> 15 == 0);\n assert(shift << 15 == 0);\n}\n", + "source": "fn main(x: u16) {\n test_u16(x);\n // Safety: testing context\n unsafe {\n test_u16_unconstrained(x);\n }\n}\n\nunconstrained fn test_u16_unconstrained(x: u16) {\n test_u16(x)\n}\n\nfn test_u16(x: u16) {\n let t1: u16 = 1234;\n let t2: u16 = 4321;\n let t = t1 + t2;\n\n let t4 = t - t2;\n assert(t4 == t1);\n\n let mut small_int = x as u16;\n let shift = small_int << x;\n assert(shift == 8);\n assert(shift >> x == small_int);\n assert(shift >> 15 == 0);\n assert(shift << 15 == 0);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_true_inliner_0.snap index 2ba6c73c0dc..5c66acfc8ab 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_true_inliner_0.snap @@ -37,12 +37,12 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U16) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 22 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(3), source: Direct(0) }, Mov { destination: Relative(4), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(2) }, Call { location: 28 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 27 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 22 }, Cast { destination: Relative(3), source: Relative(1), bit_size: Integer(U8) }, Cast { destination: Relative(2), source: Relative(3), bit_size: Integer(U16) }, Cast { destination: Relative(3), source: Relative(2), bit_size: Integer(U8) }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U8, lhs: Relative(3), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(5), location: 38 }, Call { location: 56 }, Const { destination: Relative(4), bit_size: Integer(U16), value: 8 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 43 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 48 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 15 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 55 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U16) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 22 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(3), source: Direct(0) }, Mov { destination: Relative(4), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(2) }, Call { location: 28 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 27 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 22 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U16, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(3), location: 34 }, Call { location: 53 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(1), rhs: Relative(1) }, Const { destination: Relative(3), bit_size: Integer(U16), value: 8 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 40 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 45 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U16), value: 15 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 52 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pdPdjkQwGAbge+lxD/qjilsRkaImTZqSDptsxL3vx8esOdhkY048qt4XjS6ks838qF3ohycpyoU00XnvHrUfWjO5IcDVhbDtwBUpOCU8RTSSIfmOYAiMBCWSIRwRpJCARBJEISmiEehMgHwnYQhHBAItCoCWFFBIimgEWjSQ7yhoyQCOCEQi0JKtKyXnN9dTtHb75MsiwNKMJtowkSLM3lPyZfy83/QcTdidTIRZRokNHQiFvfN2O1vpb5r9HRXiyEr5Cqt/p2X+iuf5nbzOjnzC2I18wuWZF3feP5H6zCv1WT7NbuQVP9dP3Xr/a/79+RWMTOvi26Zat6boTOPtMezn0F5mp+/xnDk35RiH1nZztFvTZWfCsYSfR+gKtiL84qVKqcqqdXv0Dw==", + "debug_symbols": "pdPRioQgFAbgd/HaC9PM7FUiwsoGQSycWliid99Tp3abi4Whuekbx/6/rFxIZ5v5UbvQD09SlAtpovPePWo/tGZyQ4B/F8K2QyJJkVCSZIhCckTvcIbAiFMiGJIgHBFIikCnADJEITmid1JoSQFokQBHBJIi0JIBGQItCsgRvSMZAi1qXSk5l1dP0dptdZf1wlMYTbRhIkWYvafky/h5P+k5mrA7mQizjBIbOhAKe+ft9mulf2n2f5TzIyvEb1i+nRYqP+Oa38inTB75NJF38lyfeaE/y8tb96+zIy+Z+iyfvF6/gpFpXXz5/tetKTrTeHsM+zm0l9npezxnzv0zxqG13Rzt1nTZRHAs4eVzVcGuga+xlIJKWa3bpX8A", "file_map": { "50": { - "source": "fn main(x: u16) {\n test_u16(x);\n // Safety: testing context\n unsafe {\n test_u16_unconstrained(x);\n }\n}\n\nunconstrained fn test_u16_unconstrained(x: u16) {\n test_u16(x)\n}\n\nfn test_u16(x: u16) {\n let t1: u16 = 1234;\n let t2: u16 = 4321;\n let t = t1 + t2;\n\n let t4 = t - t2;\n assert(t4 == t1);\n\n let mut small_int = x as u16;\n let shift = small_int << (x as u8);\n assert(shift == 8);\n assert(shift >> (x as u8) == small_int);\n assert(shift >> 15 == 0);\n assert(shift << 15 == 0);\n}\n", + "source": "fn main(x: u16) {\n test_u16(x);\n // Safety: testing context\n unsafe {\n test_u16_unconstrained(x);\n }\n}\n\nunconstrained fn test_u16_unconstrained(x: u16) {\n test_u16(x)\n}\n\nfn test_u16(x: u16) {\n let t1: u16 = 1234;\n let t2: u16 = 4321;\n let t = t1 + t2;\n\n let t4 = t - t2;\n assert(t4 == t1);\n\n let mut small_int = x as u16;\n let shift = small_int << x;\n assert(shift == 8);\n assert(shift >> x == small_int);\n assert(shift >> 15 == 0);\n assert(shift << 15 == 0);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index e613db5b54c..e16566231fd 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u16_support/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -37,12 +37,12 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [EXPR [ (1, _0) 0 ]], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U16) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 42 }, Cast { destination: Relative(3), source: Relative(1), bit_size: Integer(U8) }, Cast { destination: Relative(2), source: Relative(3), bit_size: Integer(U16) }, Cast { destination: Relative(3), source: Relative(2), bit_size: Integer(U8) }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 16 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U8, lhs: Relative(3), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(5), location: 24 }, Call { location: 48 }, Const { destination: Relative(4), bit_size: Integer(U16), value: 8 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 29 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 34 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 15 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 41 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 47 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U16) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 39 }, Const { destination: Relative(2), bit_size: Integer(U16), value: 16 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U16, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(3), location: 20 }, Call { location: 45 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(1), rhs: Relative(1) }, Const { destination: Relative(3), bit_size: Integer(U16), value: 8 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 26 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(2), op: Shr, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 31 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U16), value: 15 }, BinaryIntOp { destination: Relative(2), op: Shl, bit_size: U16, lhs: Relative(3), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U16), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U16, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 38 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 44 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14514982005979867414 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZPNroMgEEbfhTULfgV9laZpqKUNCUFD9SY3je9+B0d7ddGN3XDE8XwwJvMiN38dH5eQ7t2TNKcXueYQY3hcYte6IXQJ3r4IKwvXpBGU8AphEJY0ElDPEAzBEQIhEYo0CqARFcIgLAJSNCUSUioARwiERECKAWgEpFiAQVhEPUNBip0mStZOLkP2vjSyaQ0a7l32aSBNGmOk5MfFcf7o2bs0c3AZqowSn25ACLyH6MvTRP9t9lkVYnGlfMt6b/PPtqzfel0f8Y1dfMXYAV9xufriyP2VNKuv9Xd+ZQ/4mq//Tx+6/9bfn3+GnWtD3o3KVJJycNfol+19TO2mOvz2a2UdtT53rb+N2ZekzbzBelKCKnOGAeNlY6lm56kc/Qc=", + "debug_symbols": "pZNNjoQgEEbvwpoF8qONVzHGoGKHhKChdZKJ8e5TWjqti97YG54I76NIqJm0tp6elQtd/yJ5MZM6Ou/ds/J9Y0bXB/g7E7YOiSI5pyRJERnigdAbOEMkJBcAjhAIiVAISJEASFGAB0JvEAwBKSmAIyAlA0iEQqQISMmWhZKj6GqM1q41n24BdxtMtGEkeZi8p+TH+Gnb9BpM2DiaCKuMEhtaIAR2ztv1a6Fvm31WOd9dIf5ldbWTz7bIHoeu+Q1fMrX7MlF3fK4PX+jvfHWrfp3uvmLZd35yPb+EmWlcvLzqZU2KztTe7tNuCs1pdfwdjpWjK4bYN7adol2TTq0BYyE0lbKEXoB3W0hFZVYu69F/", "file_map": { "50": { - "source": "fn main(x: u16) {\n test_u16(x);\n // Safety: testing context\n unsafe {\n test_u16_unconstrained(x);\n }\n}\n\nunconstrained fn test_u16_unconstrained(x: u16) {\n test_u16(x)\n}\n\nfn test_u16(x: u16) {\n let t1: u16 = 1234;\n let t2: u16 = 4321;\n let t = t1 + t2;\n\n let t4 = t - t2;\n assert(t4 == t1);\n\n let mut small_int = x as u16;\n let shift = small_int << (x as u8);\n assert(shift == 8);\n assert(shift >> (x as u8) == small_int);\n assert(shift >> 15 == 0);\n assert(shift << 15 == 0);\n}\n", + "source": "fn main(x: u16) {\n test_u16(x);\n // Safety: testing context\n unsafe {\n test_u16_unconstrained(x);\n }\n}\n\nunconstrained fn test_u16_unconstrained(x: u16) {\n test_u16(x)\n}\n\nfn test_u16(x: u16) {\n let t1: u16 = 1234;\n let t2: u16 = 4321;\n let t = t1 + t2;\n\n let t4 = t - t2;\n assert(t4 == t1);\n\n let mut small_int = x as u16;\n let shift = small_int << x;\n assert(shift == 8);\n assert(shift >> x == small_int);\n assert(shift >> 15 == 0);\n assert(shift << 15 == 0);\n}\n", "path": "" } }, diff --git a/tooling/ssa_fuzzer/src/builder.rs b/tooling/ssa_fuzzer/src/builder.rs index 512058a9d71..2494634849a 100644 --- a/tooling/ssa_fuzzer/src/builder.rs +++ b/tooling/ssa_fuzzer/src/builder.rs @@ -235,9 +235,6 @@ impl FuzzerBuilder { /// Inserts a left shift instruction between two values /// The right hand side is cast to 8 bits pub fn insert_shl_instruction(&mut self, lhs: TypedValue, rhs: TypedValue) -> TypedValue { - // rhs must be 8bit, otherwise compiler will throw panic... - // TODO(sn): make something smarter than forcing rhs to be u8 and casting to u64 on field - let rhs = self.insert_cast(rhs, ValueType::U8); if !lhs.supports_shift() { return lhs; } @@ -248,8 +245,6 @@ impl FuzzerBuilder { /// Inserts a right shift instruction between two values /// The right hand side is cast to 8 bits pub fn insert_shr_instruction(&mut self, lhs: TypedValue, rhs: TypedValue) -> TypedValue { - // TODO(sn): make something smarter than forcing rhs to be u8 and casting to u64 on field - let rhs = self.insert_cast(rhs, ValueType::U8); if !lhs.supports_shift() { return lhs; } diff --git a/tooling/ssa_verification/src/main.rs b/tooling/ssa_verification/src/main.rs index fce0af933e7..0d5a0980771 100644 --- a/tooling/ssa_verification/src/main.rs +++ b/tooling/ssa_verification/src/main.rs @@ -82,8 +82,6 @@ fn main() { let u64_var = Variable { variable_type: VariableType::Unsigned, variable_size: 64 }; // 32 bit unsigned let u32_var = Variable { variable_type: VariableType::Unsigned, variable_size: 32 }; - // 8 bit unsigned - let u8_var = Variable { variable_type: VariableType::Unsigned, variable_size: 8 }; // Tests for bitvector operations with max bit size (128 bits) all_artifacts.push(InstructionArtifacts::new_add(&u128_var, &u128_var)); @@ -122,9 +120,9 @@ fn main() { // shl truncates variable, so test different sizes // Too heavy to test 127 bits, but it just multiplies or divides by 2^rhs // Should work the same if div and mul are verified - all_artifacts.push(InstructionArtifacts::new_shl(&u64_var, &u8_var)); - all_artifacts.push(InstructionArtifacts::new_shr(&u64_var, &u8_var)); - all_artifacts.push(InstructionArtifacts::new_shl(&u32_var, &u8_var)); + all_artifacts.push(InstructionArtifacts::new_shl(&u64_var, &u64_var)); + all_artifacts.push(InstructionArtifacts::new_shr(&u64_var, &u64_var)); + all_artifacts.push(InstructionArtifacts::new_shl(&u32_var, &u32_var)); // Test binary operations with 32 bits all_artifacts.push(InstructionArtifacts::new_xor(&u32_var, &u32_var));