From 6e7b4a2544bcb63a349526f57c5e5e9e56be1e64 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 30 Jun 2025 14:57:43 +0000
Subject: [PATCH 1/2] fix: mark all signed binary ops as unchecked

---
 compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs   | 11 ++++++++++-
 .../execution_success/regression_9047/Nargo.toml      |  6 ++++++
 .../execution_success/regression_9047/src/main.nr     | 11 +++++++++++
 3 files changed, 27 insertions(+), 1 deletion(-)
 create mode 100644 test_programs/execution_success/regression_9047/Nargo.toml
 create mode 100644 test_programs/execution_success/regression_9047/src/main.nr

diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index e8b9cdcfbe3..2b730d2105d 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -564,11 +564,20 @@ impl<'a> FunctionContext<'a> {
         mut rhs: ValueId,
         location: Location,
     ) -> Values {
-        let op = convert_operator(operator);
+        let mut op = convert_operator(operator);
         if operator_requires_swapped_operands(operator) {
             std::mem::swap(&mut lhs, &mut rhs);
         }
 
+        if matches!(self.builder.type_of_value(lhs), Type::Numeric(NumericType::Signed { .. })) {
+            op = match op {
+                BinaryOp::Add { .. } => BinaryOp::Add { unchecked: true },
+                BinaryOp::Sub { .. } => BinaryOp::Sub { unchecked: true },
+                BinaryOp::Mul { .. } => BinaryOp::Mul { unchecked: true },
+                op => op,
+            };
+        }
+
         let mut result = self.builder.set_location(location).insert_binary(lhs, op, rhs);
 
         // Check for integer overflow
diff --git a/test_programs/execution_success/regression_9047/Nargo.toml b/test_programs/execution_success/regression_9047/Nargo.toml
new file mode 100644
index 00000000000..8b7dc3a97be
--- /dev/null
+++ b/test_programs/execution_success/regression_9047/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "regression_9047"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/regression_9047/src/main.nr b/test_programs/execution_success/regression_9047/src/main.nr
new file mode 100644
index 00000000000..240f12b4b75
--- /dev/null
+++ b/test_programs/execution_success/regression_9047/src/main.nr
@@ -0,0 +1,11 @@
+fn main() -> pub str<2> {
+    let mut b = 0_i8;
+    if unsafe { func_1_proxy() } {
+        b = 112;
+        b = ((-b) * b);
+    };
+    "ok"
+}
+unconstrained fn func_1_proxy() -> bool {
+    false
+}

From 030669b5227b072650ff4d0998481ff24d5e90c7 Mon Sep 17 00:00:00 2001
From: Tom French <15848336+TomAFrench@users.noreply.github.com>
Date: Mon, 30 Jun 2025 17:42:57 +0000
Subject: [PATCH 2/2] .

---
 ...te__tests__force_brillig_true_inliner_0.snap |  4 ++--
 .../execute__tests__expanded.snap               | 17 +++++++++++++++++
 .../regression_9047/execute__tests__stdout.snap |  5 +++++
 3 files changed, 24 insertions(+), 2 deletions(-)
 create mode 100644 tooling/nargo_cli/tests/snapshots/execution_success/regression_9047/execute__tests__expanded.snap
 create mode 100644 tooling/nargo_cli/tests/snapshots/execution_success/regression_9047/execute__tests__stdout.snap

diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/higher_order_functions/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/higher_order_functions/execute__tests__force_brillig_true_inliner_0.snap
index 5c0d5abb9ad..49da860585d 100644
--- a/tooling/nargo_cli/tests/snapshots/execution_success/higher_order_functions/execute__tests__force_brillig_true_inliner_0.snap
+++ b/tooling/nargo_cli/tests/snapshots/execution_success/higher_order_functions/execute__tests__force_brillig_true_inliner_0.snap
@@ -48,9 +48,9 @@ expression: artifact
     "return value indices : [_1]",
     "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: [Simple(Witness(1))]",
     "unconstrained func 0",
-    "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32845 }, 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(32843), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32843) }, Call { location: 13 }, Call { location: 22 }, Mov { destination: Direct(32844), source: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32837), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 3 }, Const { destination: Direct(32840), bit_size: Field, value: 17 }, Const { destination: Direct(32841), bit_size: Field, value: 33 }, Const { destination: Direct(32842), bit_size: Integer(U32), value: 2147483648 }, Return, Call { location: 32 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(3), source: Direct(0) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(2) }, Call { location: 38 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(2), bit_size: Field, value: 5 }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(1), rhs: Relative(2) }, 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: 37 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 32 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, 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(7), source: Relative(6) }, Store { destination_pointer: Relative(7), source: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(3) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(4) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 59 }, Call { location: 510 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Relative(5) }, Mov { destination: Relative(10), source: Relative(3) }, Mov { destination: Relative(11), source: Direct(32840) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 513 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(4), source: Relative(9) }, Load { destination: Relative(7), source_pointer: Relative(4) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 76 }, Call { location: 510 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(7) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, Load { destination: Relative(7), source_pointer: Relative(9) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 2147483648 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(12) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(12) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2147483648 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(14) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 2147483648 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(16) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(16) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Relative(15) }, JumpIf { condition: Relative(9), location: 100 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, JumpIf { condition: Relative(10), location: 103 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, JumpIf { condition: Relative(13), location: 106 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 112 }, Call { location: 510 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, 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: Direct(32837) }, Load { destination: Relative(10), source_pointer: Relative(4) }, 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: 123 }, Call { location: 510 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(10) }, Mov { destination: Relative(1), source: Direct(32836) }, Jump { location: 127 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 496 }, Jump { location: 130 }, Load { destination: Relative(6), source_pointer: Relative(2) }, JumpIf { condition: Relative(6), location: 134 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 140 }, Call { location: 510 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, 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: Direct(32835) }, Load { destination: Relative(8), source_pointer: Relative(4) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 151 }, Call { location: 510 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(8) }, Mov { destination: Relative(1), source: Direct(32836) }, Jump { location: 155 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 474 }, Jump { location: 158 }, Load { destination: Relative(6), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 164 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(6), source_pointer: Relative(4) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(6) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 170 }, Call { location: 510 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(6) }, 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: Direct(32835) }, Load { destination: Relative(9), source_pointer: Relative(4) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 181 }, Call { location: 510 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(9) }, Mov { destination: Relative(1), source: Direct(32836) }, Jump { location: 185 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32839) }, JumpIf { condition: Relative(8), location: 443 }, Jump { location: 188 }, Load { destination: Relative(8), source_pointer: Relative(6) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 18 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(6) }, JumpIf { condition: Relative(9), location: 194 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(6), source_pointer: Relative(4) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(6) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 200 }, Call { location: 510 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(6) }, 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(7) }, Load { destination: Relative(9), source_pointer: Relative(4) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 211 }, Call { location: 510 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(9) }, Mov { destination: Relative(1), source: Direct(32838) }, Jump { location: 215 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32839) }, JumpIf { condition: Relative(8), location: 421 }, Jump { location: 218 }, Load { destination: Relative(8), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 223 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 229 }, Call { location: 510 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, 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(7) }, Load { destination: Relative(8), source_pointer: Relative(4) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 240 }, Call { location: 510 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(8) }, Mov { destination: Relative(1), source: Direct(32838) }, Jump { location: 244 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 390 }, Jump { location: 247 }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 16 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 253 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(1), source_pointer: Relative(4) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 259 }, Call { location: 510 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2147483647 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Relative(7) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U32, lhs: Relative(15), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 267 }, Jump { location: 269 }, Mov { destination: Relative(8), source: Relative(16) }, Jump { location: 271 }, Mov { destination: Relative(8), source: Relative(7) }, Jump { location: 271 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2147483647 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, JumpIf { condition: Relative(9), location: 277 }, Jump { location: 279 }, Mov { destination: Relative(10), source: Relative(16) }, Jump { location: 281 }, Mov { destination: Relative(10), source: Relative(3) }, Jump { location: 281 }, BinaryIntOp { destination: Relative(1), op: Div, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Xor, bit_size: U1, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(13), location: 285 }, Jump { location: 287 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2147483647 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Relative(11) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, JumpIf { condition: Relative(7), location: 293 }, Jump { location: 295 }, Mov { destination: Relative(8), source: Relative(16) }, Jump { location: 297 }, Mov { destination: Relative(8), source: Relative(11) }, Jump { location: 297 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2147483647 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, JumpIf { condition: Relative(9), location: 303 }, Jump { location: 305 }, Mov { destination: Relative(10), source: Relative(16) }, Jump { location: 307 }, Mov { destination: Relative(10), source: Relative(3) }, Jump { location: 307 }, BinaryIntOp { destination: Relative(6), op: Div, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Xor, bit_size: U1, lhs: Relative(7), rhs: Relative(9) }, JumpIf { condition: Relative(13), location: 311 }, Jump { location: 313 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(14), rhs: Relative(6) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2147483647 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Relative(12) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, JumpIf { condition: Relative(8), location: 319 }, Jump { location: 321 }, Mov { destination: Relative(9), source: Relative(16) }, Jump { location: 323 }, Mov { destination: Relative(9), source: Relative(12) }, Jump { location: 323 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2147483647 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, JumpIf { condition: Relative(10), location: 329 }, Jump { location: 331 }, Mov { destination: Relative(11), source: Relative(16) }, Jump { location: 333 }, Mov { destination: Relative(11), source: Relative(3) }, Jump { location: 333 }, BinaryIntOp { destination: Relative(7), op: Div, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(13), op: Xor, bit_size: U1, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 337 }, Jump { location: 339 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Sub, bit_size: U32, lhs: Relative(14), rhs: Relative(7) }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 4 }, 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) }, 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(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(7) }, Load { destination: Relative(1), source_pointer: Relative(5) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 356 }, Call { location: 510 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 9 }, Mov { destination: Relative(9), source: Direct(0) }, Mov { destination: Relative(10), source: Relative(8) }, Mov { destination: Relative(11), source: Relative(5) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 675 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(10) }, JumpIf { condition: Relative(1), location: 369 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(7), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Relative(4) }, Mov { destination: Relative(10), source: Relative(3) }, Mov { destination: Relative(11), source: Direct(32841) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 513 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(9) }, Const { destination: Relative(4), 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(5) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 675 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(8) }, JumpIf { condition: Relative(3), location: 389 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(1) } }, Return, Load { destination: Relative(6), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, Mov { destination: Relative(10), source: Relative(9) }, Cast { destination: Relative(9), source: Relative(10), bit_size: Integer(U32) }, Cast { destination: Relative(13), source: Relative(6), bit_size: Integer(U32) }, Cast { destination: Relative(6), source: Relative(8), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(9), rhs: Relative(6) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(6) }, JumpIf { condition: Relative(9), location: 408 }, Call { location: 707 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(3) }, Mov { destination: Relative(8), source: Relative(6) }, Cast { destination: Relative(6), source: Relative(8), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(13) }, BinaryIntOp { destination: Relative(9), op: Mul, bit_size: U1, lhs: Relative(6), rhs: Relative(13) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(6), location: 417 }, Call { location: 707 }, Store { destination_pointer: Relative(2), source: Relative(8) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 244 }, Load { destination: Relative(8), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Load { destination: Relative(9), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, Mov { destination: Relative(13), source: Relative(10) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U32) }, Cast { destination: Relative(14), source: Relative(8), bit_size: Integer(U32) }, Cast { destination: Relative(8), source: Relative(9), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U1, lhs: Relative(14), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Mul, bit_size: U1, lhs: Relative(10), rhs: Relative(8) }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(8) }, JumpIf { condition: Relative(10), location: 439 }, Call { location: 707 }, Store { destination_pointer: Relative(6), 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: 215 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Mov { destination: Relative(13), source: Relative(10) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U32) }, Cast { destination: Relative(14), source: Relative(9), bit_size: Integer(U32) }, Cast { destination: Relative(9), source: Relative(8), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U1, lhs: Relative(14), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(10), rhs: Relative(9) }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(10), location: 461 }, Call { location: 707 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(3) }, Mov { destination: Relative(9), source: Relative(8) }, Cast { destination: Relative(8), source: Relative(9), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U1, lhs: Relative(10), rhs: Relative(14) }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U1, lhs: Relative(8), rhs: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U1, lhs: Relative(10), rhs: Relative(14) }, JumpIf { condition: Relative(8), location: 470 }, Call { location: 707 }, Store { destination_pointer: Relative(6), source: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 185 }, 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(1) }, Load { destination: Relative(6), source_pointer: Relative(9) }, Load { destination: Relative(8), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(6) }, Mov { destination: Relative(10), source: Relative(9) }, Cast { destination: Relative(9), source: Relative(10), bit_size: Integer(U32) }, Cast { destination: Relative(13), source: Relative(8), bit_size: Integer(U32) }, Cast { destination: Relative(8), source: Relative(6), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U1, lhs: Relative(6), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(13), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(9), rhs: Relative(8) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 492 }, Call { location: 707 }, Store { destination_pointer: Relative(2), source: Relative(10) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 155 }, 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(1) }, Load { destination: Relative(6), source_pointer: Relative(9) }, Load { destination: Relative(8), source_pointer: Relative(2) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2147483648 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(14) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(13) }, Not { destination: Relative(6), source: Relative(9), bit_size: U1 }, BinaryIntOp { destination: Relative(9), op: Mul, bit_size: U1, lhs: Relative(8), rhs: Relative(6) }, Store { destination_pointer: Relative(2), source: Relative(9) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 127 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, 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(7), source: Relative(6) }, Store { destination_pointer: Relative(7), source: Direct(32835) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32835) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32835) }, 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(5) }, Load { destination: Relative(5), source_pointer: Relative(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(5) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 534 }, Call { location: 510 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(3), rhs: Direct(32840) }, Cast { destination: Relative(8), source: Relative(2), bit_size: Field }, Const { destination: Relative(9), bit_size: Field, value: 4294967296 }, BinaryFieldOp { destination: Relative(10), op: Sub, lhs: Relative(9), rhs: Relative(8) }, Const { destination: Relative(11), bit_size: Field, value: 23 }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(3), rhs: Relative(11) }, Const { destination: Relative(11), bit_size: Field, value: 27 }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(3), rhs: Relative(11) }, Mov { destination: Relative(4), source: Direct(32836) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 551 }, Jump { location: 549 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Return, 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(4) }, Load { destination: Relative(11), source_pointer: Relative(15) }, Cast { destination: Relative(14), source: Relative(2), bit_size: Integer(U32) }, Cast { destination: Relative(15), source: Relative(11), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32842) }, JumpIf { condition: Relative(5), location: 626 }, Jump { location: 562 }, JumpIf { condition: Relative(12), location: 612 }, Jump { location: 564 }, JumpIf { condition: Relative(13), location: 598 }, Jump { location: 566 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(3), rhs: Direct(32841) }, JumpIf { condition: Relative(16), location: 570 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 2147483647 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Sub, bit_size: U32, lhs: Relative(23), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 576 }, Jump { location: 578 }, Mov { destination: Relative(18), source: Relative(24) }, Jump { location: 580 }, Mov { destination: Relative(18), source: Relative(11) }, Jump { location: 580 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 2147483647 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Sub, bit_size: U32, lhs: Relative(23), rhs: Relative(2) }, JumpIf { condition: Relative(19), location: 586 }, Jump { location: 588 }, Mov { destination: Relative(20), source: Relative(24) }, Jump { location: 590 }, Mov { destination: Relative(20), source: Relative(2) }, Jump { location: 590 }, BinaryIntOp { destination: Relative(16), op: Div, bit_size: U32, 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: 594 }, Jump { location: 596 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(16) }, Mov { destination: Relative(15), source: Relative(16) }, Jump { location: 610 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(11) }, Mov { destination: Relative(11), source: Relative(16) }, Cast { destination: Relative(16), source: Relative(11), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U1, lhs: Relative(18), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U32, lhs: Relative(16), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Mul, bit_size: U1, lhs: Relative(16), rhs: Relative(17) }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U1, lhs: Relative(18), rhs: Relative(17) }, JumpIf { condition: Relative(16), location: 608 }, Call { location: 707 }, Mov { destination: Relative(15), source: Relative(11) }, Jump { location: 610 }, Mov { destination: Relative(14), source: Relative(15) }, Jump { location: 624 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(11) }, Mov { destination: Relative(11), source: Relative(15) }, Cast { destination: Relative(15), source: Relative(11), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U1, lhs: Relative(16), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U1, lhs: Relative(17), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Mul, bit_size: U1, lhs: Relative(15), rhs: Relative(18) }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U1, lhs: Relative(16), rhs: Relative(18) }, JumpIf { condition: Relative(15), location: 622 }, Call { location: 707 }, Mov { destination: Relative(14), source: Relative(11) }, Jump { location: 624 }, Mov { destination: Relative(7), source: Relative(14) }, Jump { location: 663 }, BinaryIntOp { destination: Relative(16), op: Mul, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Cast { destination: Relative(17), source: Relative(16), bit_size: Integer(U64) }, Cast { destination: Relative(18), source: Relative(17), bit_size: Integer(U32) }, Cast { destination: Relative(16), source: Relative(18), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U1, lhs: Relative(17), rhs: Relative(15) }, Not { destination: Relative(18), source: Relative(17), bit_size: U1 }, Cast { destination: Relative(19), source: Relative(11), bit_size: Field }, Cast { destination: Relative(11), source: Relative(17), bit_size: Field }, BinaryFieldOp { destination: Relative(17), op: Mul, lhs: Relative(11), rhs: Relative(19) }, BinaryFieldOp { destination: Relative(11), op: Sub, lhs: Relative(9), rhs: Relative(19) }, Cast { destination: Relative(19), source: Relative(18), bit_size: Field }, BinaryFieldOp { destination: Relative(18), op: Mul, lhs: Relative(19), rhs: Relative(11) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(17), rhs: Relative(18) }, Not { destination: Relative(17), source: Relative(15), bit_size: U1 }, Cast { destination: Relative(18), source: Relative(15), bit_size: Field }, BinaryFieldOp { destination: Relative(15), op: Mul, lhs: Relative(18), rhs: Relative(8) }, Cast { destination: Relative(18), source: Relative(17), bit_size: Field }, BinaryFieldOp { destination: Relative(17), op: Mul, lhs: Relative(18), rhs: Relative(10) }, BinaryFieldOp { destination: Relative(18), op: Add, lhs: Relative(15), rhs: Relative(17) }, BinaryFieldOp { destination: Relative(15), op: Mul, lhs: Relative(11), rhs: Relative(18) }, Cast { destination: Relative(11), source: Relative(15), bit_size: Field }, Const { destination: Relative(17), bit_size: Field, value: 4294967295 }, BinaryFieldOp { destination: Relative(18), op: LessThanEquals, lhs: Relative(11), rhs: Relative(17) }, JumpIf { condition: Relative(18), location: 653 }, Call { location: 710 }, Cast { destination: Relative(11), source: Relative(15), bit_size: Integer(U32) }, Not { destination: Relative(15), source: Relative(14), bit_size: U1 }, Cast { destination: Relative(14), source: Relative(15), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Direct(32842), rhs: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(15) }, JumpIf { condition: Relative(14), location: 660 }, Call { location: 707 }, Cast { destination: Relative(11), source: Relative(16), bit_size: Integer(U32) }, Mov { destination: Relative(7), source: Relative(11) }, Jump { location: 663 }, Load { destination: Relative(11), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 4 }, Call { location: 713 }, 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(4) }, Store { destination_pointer: Relative(16), source: Relative(7) }, Store { destination_pointer: Relative(6), source: Relative(14) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, Mov { destination: Relative(4), source: Relative(7) }, Jump { location: 546 }, Call { location: 32 }, 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(32837) }, Load { destination: Relative(5), source_pointer: Relative(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 685 }, Call { location: 510 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(5) }, Mov { destination: Relative(3), source: Direct(32836) }, Jump { location: 689 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 694 }, Jump { location: 692 }, 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: U32, 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(32838) }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 689 }, 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, 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: 717 }, Jump { location: 719 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 734 }, 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: 731 }, 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: 724 }, 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: 734 }, Return]"
+    "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32845 }, 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(32843), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32843) }, Call { location: 13 }, Call { location: 22 }, Mov { destination: Direct(32844), source: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32837), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 3 }, Const { destination: Direct(32840), bit_size: Field, value: 17 }, Const { destination: Direct(32841), bit_size: Field, value: 33 }, Const { destination: Direct(32842), bit_size: Integer(U32), value: 2147483648 }, Return, Call { location: 32 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(3), source: Direct(0) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(2) }, Call { location: 38 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(2), bit_size: Field, value: 5 }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(1), rhs: Relative(2) }, 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: 37 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 32 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, 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(7), source: Relative(6) }, Store { destination_pointer: Relative(7), source: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(3) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(4) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 59 }, Call { location: 510 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Relative(5) }, Mov { destination: Relative(10), source: Relative(3) }, Mov { destination: Relative(11), source: Direct(32840) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 513 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(4), source: Relative(9) }, Load { destination: Relative(7), source_pointer: Relative(4) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 76 }, Call { location: 510 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(7) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, Load { destination: Relative(7), source_pointer: Relative(9) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 2147483648 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(12) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(12) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2147483648 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(14) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, Load { destination: Relative(12), source_pointer: Relative(13) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 2147483648 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(16) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(16) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Relative(15) }, JumpIf { condition: Relative(9), location: 100 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, JumpIf { condition: Relative(10), location: 103 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, JumpIf { condition: Relative(13), location: 106 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 112 }, Call { location: 510 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, 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: Direct(32837) }, Load { destination: Relative(10), source_pointer: Relative(4) }, 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: 123 }, Call { location: 510 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(10) }, Mov { destination: Relative(1), source: Direct(32836) }, Jump { location: 127 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 496 }, Jump { location: 130 }, Load { destination: Relative(6), source_pointer: Relative(2) }, JumpIf { condition: Relative(6), location: 134 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 140 }, Call { location: 510 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, 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: Direct(32835) }, Load { destination: Relative(8), source_pointer: Relative(4) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 151 }, Call { location: 510 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(8) }, Mov { destination: Relative(1), source: Direct(32836) }, Jump { location: 155 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 474 }, Jump { location: 158 }, Load { destination: Relative(6), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 164 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(6), source_pointer: Relative(4) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(6) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 170 }, Call { location: 510 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(6) }, 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: Direct(32835) }, Load { destination: Relative(9), source_pointer: Relative(4) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 181 }, Call { location: 510 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(9) }, Mov { destination: Relative(1), source: Direct(32836) }, Jump { location: 185 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32839) }, JumpIf { condition: Relative(8), location: 443 }, Jump { location: 188 }, Load { destination: Relative(8), source_pointer: Relative(6) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 18 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(6) }, JumpIf { condition: Relative(9), location: 194 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(6), source_pointer: Relative(4) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(6) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 200 }, Call { location: 510 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(6) }, 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(7) }, Load { destination: Relative(9), source_pointer: Relative(4) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 211 }, Call { location: 510 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(9) }, Mov { destination: Relative(1), source: Direct(32838) }, Jump { location: 215 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32839) }, JumpIf { condition: Relative(8), location: 421 }, Jump { location: 218 }, Load { destination: Relative(8), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 223 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 229 }, Call { location: 510 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, 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(7) }, Load { destination: Relative(8), source_pointer: Relative(4) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 240 }, Call { location: 510 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(8) }, Mov { destination: Relative(1), source: Direct(32838) }, Jump { location: 244 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 390 }, Jump { location: 247 }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 16 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 253 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(1), source_pointer: Relative(4) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 259 }, Call { location: 510 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2147483647 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Relative(7) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U32, lhs: Relative(15), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 267 }, Jump { location: 269 }, Mov { destination: Relative(8), source: Relative(16) }, Jump { location: 271 }, Mov { destination: Relative(8), source: Relative(7) }, Jump { location: 271 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2147483647 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, JumpIf { condition: Relative(9), location: 277 }, Jump { location: 279 }, Mov { destination: Relative(10), source: Relative(16) }, Jump { location: 281 }, Mov { destination: Relative(10), source: Relative(3) }, Jump { location: 281 }, BinaryIntOp { destination: Relative(1), op: Div, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Xor, bit_size: U1, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(13), location: 285 }, Jump { location: 287 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2147483647 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Relative(11) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, JumpIf { condition: Relative(7), location: 293 }, Jump { location: 295 }, Mov { destination: Relative(8), source: Relative(16) }, Jump { location: 297 }, Mov { destination: Relative(8), source: Relative(11) }, Jump { location: 297 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2147483647 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, JumpIf { condition: Relative(9), location: 303 }, Jump { location: 305 }, Mov { destination: Relative(10), source: Relative(16) }, Jump { location: 307 }, Mov { destination: Relative(10), source: Relative(3) }, Jump { location: 307 }, BinaryIntOp { destination: Relative(6), op: Div, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, BinaryIntOp { destination: Relative(13), op: Xor, bit_size: U1, lhs: Relative(7), rhs: Relative(9) }, JumpIf { condition: Relative(13), location: 311 }, Jump { location: 313 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(14), rhs: Relative(6) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2147483647 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Relative(12) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, JumpIf { condition: Relative(8), location: 319 }, Jump { location: 321 }, Mov { destination: Relative(9), source: Relative(16) }, Jump { location: 323 }, Mov { destination: Relative(9), source: Relative(12) }, Jump { location: 323 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2147483647 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, JumpIf { condition: Relative(10), location: 329 }, Jump { location: 331 }, Mov { destination: Relative(11), source: Relative(16) }, Jump { location: 333 }, Mov { destination: Relative(11), source: Relative(3) }, Jump { location: 333 }, BinaryIntOp { destination: Relative(7), op: Div, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(13), op: Xor, bit_size: U1, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 337 }, Jump { location: 339 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Sub, bit_size: U32, lhs: Relative(14), rhs: Relative(7) }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 4 }, 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) }, 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(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(7) }, Load { destination: Relative(1), source_pointer: Relative(5) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 356 }, Call { location: 510 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 9 }, Mov { destination: Relative(9), source: Direct(0) }, Mov { destination: Relative(10), source: Relative(8) }, Mov { destination: Relative(11), source: Relative(5) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 674 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(10) }, JumpIf { condition: Relative(1), location: 369 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(7), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Relative(4) }, Mov { destination: Relative(10), source: Relative(3) }, Mov { destination: Relative(11), source: Direct(32841) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 513 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(9) }, Const { destination: Relative(4), 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(5) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 674 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(8) }, JumpIf { condition: Relative(3), location: 389 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(1) } }, Return, Load { destination: Relative(6), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, Mov { destination: Relative(10), source: Relative(9) }, Cast { destination: Relative(9), source: Relative(10), bit_size: Integer(U32) }, Cast { destination: Relative(13), source: Relative(6), bit_size: Integer(U32) }, Cast { destination: Relative(6), source: Relative(8), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(9), rhs: Relative(6) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(6) }, JumpIf { condition: Relative(9), location: 408 }, Call { location: 706 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(3) }, Mov { destination: Relative(8), source: Relative(6) }, Cast { destination: Relative(6), source: Relative(8), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(13) }, BinaryIntOp { destination: Relative(9), op: Mul, bit_size: U1, lhs: Relative(6), rhs: Relative(13) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(13) }, JumpIf { condition: Relative(6), location: 417 }, Call { location: 706 }, Store { destination_pointer: Relative(2), source: Relative(8) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 244 }, Load { destination: Relative(8), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Load { destination: Relative(9), source_pointer: Relative(13) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, Mov { destination: Relative(13), source: Relative(10) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U32) }, Cast { destination: Relative(14), source: Relative(8), bit_size: Integer(U32) }, Cast { destination: Relative(8), source: Relative(9), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U1, lhs: Relative(14), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Mul, bit_size: U1, lhs: Relative(10), rhs: Relative(8) }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(8) }, JumpIf { condition: Relative(10), location: 439 }, Call { location: 706 }, Store { destination_pointer: Relative(6), 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: 215 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Mov { destination: Relative(13), source: Relative(10) }, Cast { destination: Relative(10), source: Relative(13), bit_size: Integer(U32) }, Cast { destination: Relative(14), source: Relative(9), bit_size: Integer(U32) }, Cast { destination: Relative(9), source: Relative(8), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U1, lhs: Relative(14), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(10), rhs: Relative(9) }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(10), location: 461 }, Call { location: 706 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(3) }, Mov { destination: Relative(9), source: Relative(8) }, Cast { destination: Relative(8), source: Relative(9), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U1, lhs: Relative(10), rhs: Relative(14) }, BinaryIntOp { destination: Relative(10), op: Mul, bit_size: U1, lhs: Relative(8), rhs: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U1, lhs: Relative(10), rhs: Relative(14) }, JumpIf { condition: Relative(8), location: 470 }, Call { location: 706 }, Store { destination_pointer: Relative(6), source: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(8) }, Jump { location: 185 }, 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(1) }, Load { destination: Relative(6), source_pointer: Relative(9) }, Load { destination: Relative(8), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(6) }, Mov { destination: Relative(10), source: Relative(9) }, Cast { destination: Relative(9), source: Relative(10), bit_size: Integer(U32) }, Cast { destination: Relative(13), source: Relative(8), bit_size: Integer(U32) }, Cast { destination: Relative(8), source: Relative(6), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U1, lhs: Relative(6), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(13), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(9), rhs: Relative(8) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 492 }, Call { location: 706 }, Store { destination_pointer: Relative(2), source: Relative(10) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 155 }, 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(1) }, Load { destination: Relative(6), source_pointer: Relative(9) }, Load { destination: Relative(8), source_pointer: Relative(2) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2147483648 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(14) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(13) }, Not { destination: Relative(6), source: Relative(9), bit_size: U1 }, BinaryIntOp { destination: Relative(9), op: Mul, bit_size: U1, lhs: Relative(8), rhs: Relative(6) }, Store { destination_pointer: Relative(2), source: Relative(9) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Mov { destination: Relative(1), source: Relative(6) }, Jump { location: 127 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, 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(7), source: Relative(6) }, Store { destination_pointer: Relative(7), source: Direct(32835) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32835) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32835) }, 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(5) }, Load { destination: Relative(5), source_pointer: Relative(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(5) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 534 }, Call { location: 510 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(3), rhs: Direct(32840) }, Cast { destination: Relative(8), source: Relative(2), bit_size: Field }, Const { destination: Relative(9), bit_size: Field, value: 4294967296 }, BinaryFieldOp { destination: Relative(10), op: Sub, lhs: Relative(9), rhs: Relative(8) }, Const { destination: Relative(11), bit_size: Field, value: 23 }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(3), rhs: Relative(11) }, Const { destination: Relative(11), bit_size: Field, value: 27 }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(3), rhs: Relative(11) }, Mov { destination: Relative(4), source: Direct(32836) }, Jump { location: 546 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 551 }, Jump { location: 549 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Return, 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(4) }, Load { destination: Relative(11), source_pointer: Relative(15) }, Cast { destination: Relative(14), source: Relative(2), bit_size: Integer(U32) }, Cast { destination: Relative(15), source: Relative(11), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32842) }, JumpIf { condition: Relative(5), location: 625 }, Jump { location: 562 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(11) }, Mov { destination: Relative(20), source: Relative(15) }, JumpIf { condition: Relative(12), location: 612 }, Jump { location: 566 }, JumpIf { condition: Relative(13), location: 600 }, Jump { location: 568 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(3), rhs: Direct(32841) }, JumpIf { condition: Relative(16), location: 572 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 2147483647 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Sub, bit_size: U32, lhs: Relative(23), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 578 }, Jump { location: 580 }, Mov { destination: Relative(18), source: Relative(24) }, Jump { location: 582 }, Mov { destination: Relative(18), source: Relative(11) }, Jump { location: 582 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 2147483647 }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Sub, bit_size: U32, lhs: Relative(23), rhs: Relative(2) }, JumpIf { condition: Relative(19), location: 588 }, Jump { location: 590 }, Mov { destination: Relative(20), source: Relative(24) }, Jump { location: 592 }, Mov { destination: Relative(20), source: Relative(2) }, Jump { location: 592 }, BinaryIntOp { destination: Relative(16), op: Div, bit_size: U32, 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: 596 }, Jump { location: 598 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(16) }, Mov { destination: Relative(15), source: Relative(16) }, Jump { location: 610 }, Cast { destination: Relative(11), source: Relative(20), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U1, lhs: Relative(18), rhs: Relative(19) }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U1, lhs: Relative(17), rhs: Relative(18) }, BinaryIntOp { destination: Relative(17), op: Mul, bit_size: U1, lhs: Relative(11), rhs: Relative(16) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U1, lhs: Relative(17), rhs: Relative(16) }, JumpIf { condition: Relative(11), location: 608 }, Call { location: 706 }, Mov { destination: Relative(15), source: Relative(20) }, Jump { location: 610 }, Mov { destination: Relative(14), source: Relative(15) }, Jump { location: 623 }, Mov { destination: Relative(11), source: Relative(15) }, Cast { destination: Relative(15), source: Relative(11), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U1, lhs: Relative(16), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U1, lhs: Relative(17), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Mul, bit_size: U1, lhs: Relative(15), rhs: Relative(18) }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U1, lhs: Relative(16), rhs: Relative(18) }, JumpIf { condition: Relative(15), location: 621 }, Call { location: 706 }, Mov { destination: Relative(14), source: Relative(11) }, Jump { location: 623 }, Mov { destination: Relative(7), source: Relative(14) }, Jump { location: 662 }, BinaryIntOp { destination: Relative(16), op: Mul, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Cast { destination: Relative(17), source: Relative(16), bit_size: Integer(U64) }, Cast { destination: Relative(18), source: Relative(17), bit_size: Integer(U32) }, Cast { destination: Relative(16), source: Relative(18), bit_size: Integer(U64) }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(14), rhs: Direct(32842) }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U1, lhs: Relative(17), rhs: Relative(15) }, Not { destination: Relative(18), source: Relative(17), bit_size: U1 }, Cast { destination: Relative(19), source: Relative(11), bit_size: Field }, Cast { destination: Relative(11), source: Relative(17), bit_size: Field }, BinaryFieldOp { destination: Relative(17), op: Mul, lhs: Relative(11), rhs: Relative(19) }, BinaryFieldOp { destination: Relative(11), op: Sub, lhs: Relative(9), rhs: Relative(19) }, Cast { destination: Relative(19), source: Relative(18), bit_size: Field }, BinaryFieldOp { destination: Relative(18), op: Mul, lhs: Relative(19), rhs: Relative(11) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(17), rhs: Relative(18) }, Not { destination: Relative(17), source: Relative(15), bit_size: U1 }, Cast { destination: Relative(18), source: Relative(15), bit_size: Field }, BinaryFieldOp { destination: Relative(15), op: Mul, lhs: Relative(18), rhs: Relative(8) }, Cast { destination: Relative(18), source: Relative(17), bit_size: Field }, BinaryFieldOp { destination: Relative(17), op: Mul, lhs: Relative(18), rhs: Relative(10) }, BinaryFieldOp { destination: Relative(18), op: Add, lhs: Relative(15), rhs: Relative(17) }, BinaryFieldOp { destination: Relative(15), op: Mul, lhs: Relative(11), rhs: Relative(18) }, Cast { destination: Relative(11), source: Relative(15), bit_size: Field }, Const { destination: Relative(17), bit_size: Field, value: 4294967295 }, BinaryFieldOp { destination: Relative(18), op: LessThanEquals, lhs: Relative(11), rhs: Relative(17) }, JumpIf { condition: Relative(18), location: 652 }, Call { location: 709 }, Cast { destination: Relative(11), source: Relative(15), bit_size: Integer(U32) }, Not { destination: Relative(15), source: Relative(14), bit_size: U1 }, Cast { destination: Relative(14), source: Relative(15), bit_size: Integer(U32) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Direct(32842), rhs: Relative(14) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(15) }, JumpIf { condition: Relative(14), location: 659 }, Call { location: 706 }, Cast { destination: Relative(11), source: Relative(16), bit_size: Integer(U32) }, Mov { destination: Relative(7), source: Relative(11) }, Jump { location: 662 }, Load { destination: Relative(11), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 4 }, Call { location: 712 }, 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(4) }, Store { destination_pointer: Relative(16), source: Relative(7) }, Store { destination_pointer: Relative(6), source: Relative(14) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, Mov { destination: Relative(4), source: Relative(7) }, Jump { location: 546 }, Call { location: 32 }, 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(32837) }, Load { destination: Relative(5), source_pointer: Relative(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(5) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 684 }, Call { location: 510 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(5) }, Mov { destination: Relative(3), source: Direct(32836) }, Jump { location: 688 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 693 }, Jump { location: 691 }, 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: U32, 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(32838) }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 688 }, 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, 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: 716 }, Jump { location: 718 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 733 }, 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: 730 }, 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: 723 }, 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: 733 }, Return]"
   ],
-  "debug_symbols": "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",
+  "debug_symbols": "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",
   "file_map": {
     "3": {
       "source": "use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl<T, let N: u32> [T; N] {\n    /// Returns the length of this array.\n    ///\n    /// ```noir\n    /// fn len(self) -> Field\n    /// ```\n    ///\n    /// example\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let array = [42, 42];\n    ///     assert(array.len() == 2);\n    /// }\n    /// ```\n    #[builtin(array_len)]\n    pub fn len(self) -> u32 {}\n\n    /// Returns this array as a slice.\n    ///\n    /// ```noir\n    /// let array = [1, 2];\n    /// let slice = array.as_slice();\n    /// assert_eq(slice, &[1, 2]);\n    /// ```\n    #[builtin(as_slice)]\n    pub fn as_slice(self) -> [T] {}\n\n    /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let b = a.map(|a| a * 2);\n    /// assert_eq(b, [2, 4, 6]);\n    /// ```\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {\n        let uninitialized = crate::mem::zeroed();\n        let mut ret = [uninitialized; N];\n\n        for i in 0..self.len() {\n            ret[i] = f(self[i]);\n        }\n\n        ret\n    }\n\n    /// Applies a function to each element of this array along with its index,\n    /// returning a new array containing the mapped elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let b = a.mapi(|i, a| i + a * 2);\n    /// assert_eq(b, [2, 5, 8]);\n    /// ```\n    pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U; N] {\n        let uninitialized = crate::mem::zeroed();\n        let mut ret = [uninitialized; N];\n\n        for i in 0..self.len() {\n            ret[i] = f(i, self[i]);\n        }\n\n        ret\n    }\n\n    /// Applies a function to each element of this array.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let mut b = [0; 3];\n    /// let mut i = 0;\n    /// a.for_each(|x| {\n    ///     b[i] = x;\n    ///     i += 1;\n    /// });\n    /// assert_eq(a, b);\n    /// ```\n    pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\n        for i in 0..self.len() {\n            f(self[i]);\n        }\n    }\n\n    /// Applies a function to each element of this array along with its index.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let mut b = [0; 3];\n    /// a.for_eachi(|i, x| {\n    ///     b[i] = x;\n    /// });\n    /// assert_eq(a, b);\n    /// ```\n    pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\n        for i in 0..self.len() {\n            f(i, self[i]);\n        }\n    }\n\n    /// Applies a function to each element of the array, returning the final accumulated value. The first\n    /// parameter is the initial value.\n    ///\n    /// This is a left fold, so the given function will be applied to the accumulator and first element of\n    /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n    ///\n    /// ```rust\n    /// let a1 = [1];\n    /// let a2 = [1, 2];\n    /// let a3 = [1, 2, 3];\n    ///\n    /// let f = |a, b| a - b;\n    /// a1.fold(10, f); //=> f(10, 1)\n    /// a2.fold(10, f); //=> f(f(10, 1), 2)\n    /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n    ///\n    /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n    /// ```\n    pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n        for elem in self {\n            accumulator = f(accumulator, elem);\n        }\n        accumulator\n    }\n\n    /// Same as fold, but uses the first element as the starting element.\n    ///\n    /// Requires the input array to be non-empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [1, 2, 3, 4];\n    ///     let reduced = arr.reduce(|a, b| a + b);\n    ///     assert(reduced == 10);\n    /// }\n    /// ```\n    pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {\n        let mut accumulator = self[0];\n        for i in 1..self.len() {\n            accumulator = f(accumulator, self[i]);\n        }\n        accumulator\n    }\n\n    /// Returns true if all the elements in this array satisfy the given predicate.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [2, 2, 2, 2, 2];\n    ///     let all = arr.all(|a| a == 2);\n    ///     assert(all);\n    /// }\n    /// ```\n    pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = true;\n        for elem in self {\n            ret &= predicate(elem);\n        }\n        ret\n    }\n\n    /// Returns true if any of the elements in this array satisfy the given predicate.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [2, 2, 2, 2, 5];\n    ///     let any = arr.any(|a| a == 5);\n    ///     assert(any);\n    /// }\n    /// ```\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        for elem in self {\n            ret |= predicate(elem);\n        }\n        ret\n    }\n\n    /// Concatenates this array with another array.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr1 = [1, 2, 3, 4];\n    ///     let arr2 = [6, 7, 8, 9, 10, 11];\n    ///     let concatenated_arr = arr1.concat(arr2);\n    ///     assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n    /// }\n    /// ```\n    pub fn concat<let M: u32>(self, array2: [T; M]) -> [T; N + M] {\n        let mut result = [crate::mem::zeroed(); N + M];\n        for i in 0..N {\n            result[i] = self[i];\n        }\n        for i in 0..M {\n            result[i + N] = array2[i];\n        }\n        result\n    }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n    T: Ord + Eq,\n{\n    /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n    /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n    /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n    /// sort any type, you should use the `sort_via` function.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let arr = [42, 32];\n    ///     let sorted = arr.sort();\n    ///     assert(sorted == [32, 42]);\n    /// }\n    /// ```\n    pub fn sort(self) -> Self {\n        self.sort_via(|a, b| a <= b)\n    }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n    T: Eq,\n{\n    /// Returns a new sorted array by sorting it with a custom comparison function.\n    /// The original array remains untouched.\n    /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n    ///\n    /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let arr = [42, 32]\n    ///     let sorted_ascending = arr.sort_via(|a, b| a <= b);\n    ///     assert(sorted_ascending == [32, 42]); // verifies\n    ///\n    ///     let sorted_descending = arr.sort_via(|a, b| a >= b);\n    ///     assert(sorted_descending == [32, 42]); // does not verify\n    /// }\n    /// ```\n    pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {\n        // Safety: `sorted` array is checked to be:\n        // a. a permutation of `input`'s elements\n        // b. satisfying the predicate `ordering`\n        let sorted = unsafe { quicksort::quicksort(self, ordering) };\n\n        if !is_unconstrained() {\n            for i in 0..N - 1 {\n                assert(\n                    ordering(sorted[i], sorted[i + 1]),\n                    \"Array has not been sorted correctly according to `ordering`.\",\n                );\n            }\n            check_shuffle::check_shuffle(self, sorted);\n        }\n        sorted\n    }\n}\n\nimpl<let N: u32> [u8; N] {\n    /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n    /// the given array is interpreted as-is as a string.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let hi = [104, 105].as_str_unchecked();\n    ///     assert_eq(hi, \"hi\");\n    /// }\n    /// ```\n    #[builtin(array_as_str_unchecked)]\n    pub fn as_str_unchecked(self) -> str<N> {}\n}\n\nimpl<let N: u32> From<str<N>> for [u8; N] {\n    /// Returns an array of the string bytes.\n    fn from(s: str<N>) -> Self {\n        s.as_bytes()\n    }\n}\n\nmod test {\n    #[test]\n    fn map_empty() {\n        assert_eq([].map(|x| x + 1), []);\n    }\n\n    global arr_with_100_values: [u32; 100] = [\n        42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2, 54,\n        89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41, 19, 98,\n        53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21, 43, 86, 35,\n        21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15, 127, 81, 30, 8,\n        125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n    ];\n    global expected_with_100_values: [u32; 100] = [\n        0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30, 32,\n        32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58, 61, 62,\n        62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82, 84, 84, 86,\n        86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114, 114, 116, 118,\n        119, 120, 121, 123, 123, 123, 125, 126, 127,\n    ];\n    fn sort_u32(a: u32, b: u32) -> bool {\n        a <= b\n    }\n\n    #[test]\n    fn test_sort() {\n        let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n        let sorted = arr.sort();\n\n        let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn test_sort_100_values() {\n        let mut arr: [u32; 100] = [\n            42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n            54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n            19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n            43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n            127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n        ];\n\n        let sorted = arr.sort();\n\n        let expected: [u32; 100] = [\n            0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n            32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n            61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n            84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n            114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n        ];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn test_sort_100_values_comptime() {\n        let sorted = arr_with_100_values.sort();\n        assert(sorted == expected_with_100_values);\n    }\n\n    #[test]\n    fn test_sort_via() {\n        let mut arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n        let sorted = arr.sort_via(sort_u32);\n\n        let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn test_sort_via_100_values() {\n        let mut arr: [u32; 100] = [\n            42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n            54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n            19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n            43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n            127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n        ];\n\n        let sorted = arr.sort_via(sort_u32);\n\n        let expected: [u32; 100] = [\n            0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n            32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n            61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n            84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n            114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n        ];\n        assert(sorted == expected);\n    }\n\n    #[test]\n    fn mapi_empty() {\n        assert_eq([].mapi(|i, x| i * x + 1), []);\n    }\n\n    #[test]\n    fn for_each_empty() {\n        let empty_array: [Field; 0] = [];\n        empty_array.for_each(|_x| assert(false));\n    }\n\n    #[test]\n    fn for_eachi_empty() {\n        let empty_array: [Field; 0] = [];\n        empty_array.for_eachi(|_i, _x| assert(false));\n    }\n\n    #[test]\n    fn map_example() {\n        let a = [1, 2, 3];\n        let b = a.map(|a| a * 2);\n        assert_eq(b, [2, 4, 6]);\n    }\n\n    #[test]\n    fn mapi_example() {\n        let a = [1, 2, 3];\n        let b = a.mapi(|i, a| i + a * 2);\n        assert_eq(b, [2, 5, 8]);\n    }\n\n    #[test]\n    fn for_each_example() {\n        let a = [1, 2, 3];\n        let mut b = [0, 0, 0];\n        let b_ref = &mut b;\n        let mut i = 0;\n        let i_ref = &mut i;\n        a.for_each(|x| {\n            b_ref[*i_ref] = x * 2;\n            *i_ref += 1;\n        });\n        assert_eq(b, [2, 4, 6]);\n        assert_eq(i, 3);\n    }\n\n    #[test]\n    fn for_eachi_example() {\n        let a = [1, 2, 3];\n        let mut b = [0, 0, 0];\n        let b_ref = &mut b;\n        a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n        assert_eq(b, [2, 5, 8]);\n    }\n\n    #[test]\n    fn concat() {\n        let arr1 = [1, 2, 3, 4];\n        let arr2 = [6, 7, 8, 9, 10, 11];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n    }\n\n    #[test]\n    fn concat_zero_length_with_something() {\n        let arr1 = [];\n        let arr2 = [1];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, [1]);\n    }\n\n    #[test]\n    fn concat_something_with_zero_length() {\n        let arr1 = [1];\n        let arr2 = [];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, [1]);\n    }\n\n    #[test]\n    fn concat_zero_lengths() {\n        let arr1: [Field; 0] = [];\n        let arr2: [Field; 0] = [];\n        let concatenated_arr = arr1.concat(arr2);\n        assert_eq(concatenated_arr, []);\n    }\n}\n",
diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_9047/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_9047/execute__tests__expanded.snap
new file mode 100644
index 00000000000..122c53ae64e
--- /dev/null
+++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_9047/execute__tests__expanded.snap
@@ -0,0 +1,17 @@
+---
+source: tooling/nargo_cli/tests/execute.rs
+expression: expanded_code
+---
+fn main() -> pub str<2> {
+    let mut b: i8 = 0_i8;
+    // Safety: comment added by `nargo expand`
+    if unsafe { func_1_proxy() } {
+        b = 112_i8;
+        b = -b * b;
+    };
+    "ok"
+}
+
+unconstrained fn func_1_proxy() -> bool {
+    false
+}
diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_9047/execute__tests__stdout.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_9047/execute__tests__stdout.snap
new file mode 100644
index 00000000000..774290bd52f
--- /dev/null
+++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_9047/execute__tests__stdout.snap
@@ -0,0 +1,5 @@
+---
+source: tooling/nargo_cli/tests/execute.rs
+expression: stdout
+---
+[regression_9047] Circuit output: String("ok")